1 /* 2 * This file generated automatically from xproto.xml by c_client.py. 3 * Edit at your peril. 4 */ 5 6 #ifdef HAVE_CONFIG_H 7 #include "config.h" 8 #endif 9 #include <stdlib.h> 10 #include <string.h> 11 #include <assert.h> 12 #include <stddef.h> /* for offsetof() */ 13 #include "xcbext.h" 14 #include "xproto.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 18 19 /***************************************************************************** 20 ** 21 ** void xcb_char2b_next 22 ** 23 ** @param xcb_char2b_iterator_t *i 24 ** @returns void 25 ** 26 *****************************************************************************/ 27 28 void 29 xcb_char2b_next (xcb_char2b_iterator_t *i /**< */) 30 { 31 --i->rem; 32 ++i->data; 33 i->index += sizeof(xcb_char2b_t); 34 } 35 36 37 /***************************************************************************** 38 ** 39 ** xcb_generic_iterator_t xcb_char2b_end 40 ** 41 ** @param xcb_char2b_iterator_t i 42 ** @returns xcb_generic_iterator_t 43 ** 44 *****************************************************************************/ 45 46 xcb_generic_iterator_t 47 xcb_char2b_end (xcb_char2b_iterator_t i /**< */) 48 { 49 xcb_generic_iterator_t ret; 50 ret.data = i.data + i.rem; 51 ret.index = i.index + ((char *) ret.data - (char *) i.data); 52 ret.rem = 0; 53 return ret; 54 } 55 56 57 /***************************************************************************** 58 ** 59 ** void xcb_window_next 60 ** 61 ** @param xcb_window_iterator_t *i 62 ** @returns void 63 ** 64 *****************************************************************************/ 65 66 void 67 xcb_window_next (xcb_window_iterator_t *i /**< */) 68 { 69 --i->rem; 70 ++i->data; 71 i->index += sizeof(xcb_window_t); 72 } 73 74 75 /***************************************************************************** 76 ** 77 ** xcb_generic_iterator_t xcb_window_end 78 ** 79 ** @param xcb_window_iterator_t i 80 ** @returns xcb_generic_iterator_t 81 ** 82 *****************************************************************************/ 83 84 xcb_generic_iterator_t 85 xcb_window_end (xcb_window_iterator_t i /**< */) 86 { 87 xcb_generic_iterator_t ret; 88 ret.data = i.data + i.rem; 89 ret.index = i.index + ((char *) ret.data - (char *) i.data); 90 ret.rem = 0; 91 return ret; 92 } 93 94 95 /***************************************************************************** 96 ** 97 ** void xcb_pixmap_next 98 ** 99 ** @param xcb_pixmap_iterator_t *i 100 ** @returns void 101 ** 102 *****************************************************************************/ 103 104 void 105 xcb_pixmap_next (xcb_pixmap_iterator_t *i /**< */) 106 { 107 --i->rem; 108 ++i->data; 109 i->index += sizeof(xcb_pixmap_t); 110 } 111 112 113 /***************************************************************************** 114 ** 115 ** xcb_generic_iterator_t xcb_pixmap_end 116 ** 117 ** @param xcb_pixmap_iterator_t i 118 ** @returns xcb_generic_iterator_t 119 ** 120 *****************************************************************************/ 121 122 xcb_generic_iterator_t 123 xcb_pixmap_end (xcb_pixmap_iterator_t i /**< */) 124 { 125 xcb_generic_iterator_t ret; 126 ret.data = i.data + i.rem; 127 ret.index = i.index + ((char *) ret.data - (char *) i.data); 128 ret.rem = 0; 129 return ret; 130 } 131 132 133 /***************************************************************************** 134 ** 135 ** void xcb_cursor_next 136 ** 137 ** @param xcb_cursor_iterator_t *i 138 ** @returns void 139 ** 140 *****************************************************************************/ 141 142 void 143 xcb_cursor_next (xcb_cursor_iterator_t *i /**< */) 144 { 145 --i->rem; 146 ++i->data; 147 i->index += sizeof(xcb_cursor_t); 148 } 149 150 151 /***************************************************************************** 152 ** 153 ** xcb_generic_iterator_t xcb_cursor_end 154 ** 155 ** @param xcb_cursor_iterator_t i 156 ** @returns xcb_generic_iterator_t 157 ** 158 *****************************************************************************/ 159 160 xcb_generic_iterator_t 161 xcb_cursor_end (xcb_cursor_iterator_t i /**< */) 162 { 163 xcb_generic_iterator_t ret; 164 ret.data = i.data + i.rem; 165 ret.index = i.index + ((char *) ret.data - (char *) i.data); 166 ret.rem = 0; 167 return ret; 168 } 169 170 171 /***************************************************************************** 172 ** 173 ** void xcb_font_next 174 ** 175 ** @param xcb_font_iterator_t *i 176 ** @returns void 177 ** 178 *****************************************************************************/ 179 180 void 181 xcb_font_next (xcb_font_iterator_t *i /**< */) 182 { 183 --i->rem; 184 ++i->data; 185 i->index += sizeof(xcb_font_t); 186 } 187 188 189 /***************************************************************************** 190 ** 191 ** xcb_generic_iterator_t xcb_font_end 192 ** 193 ** @param xcb_font_iterator_t i 194 ** @returns xcb_generic_iterator_t 195 ** 196 *****************************************************************************/ 197 198 xcb_generic_iterator_t 199 xcb_font_end (xcb_font_iterator_t i /**< */) 200 { 201 xcb_generic_iterator_t ret; 202 ret.data = i.data + i.rem; 203 ret.index = i.index + ((char *) ret.data - (char *) i.data); 204 ret.rem = 0; 205 return ret; 206 } 207 208 209 /***************************************************************************** 210 ** 211 ** void xcb_gcontext_next 212 ** 213 ** @param xcb_gcontext_iterator_t *i 214 ** @returns void 215 ** 216 *****************************************************************************/ 217 218 void 219 xcb_gcontext_next (xcb_gcontext_iterator_t *i /**< */) 220 { 221 --i->rem; 222 ++i->data; 223 i->index += sizeof(xcb_gcontext_t); 224 } 225 226 227 /***************************************************************************** 228 ** 229 ** xcb_generic_iterator_t xcb_gcontext_end 230 ** 231 ** @param xcb_gcontext_iterator_t i 232 ** @returns xcb_generic_iterator_t 233 ** 234 *****************************************************************************/ 235 236 xcb_generic_iterator_t 237 xcb_gcontext_end (xcb_gcontext_iterator_t i /**< */) 238 { 239 xcb_generic_iterator_t ret; 240 ret.data = i.data + i.rem; 241 ret.index = i.index + ((char *) ret.data - (char *) i.data); 242 ret.rem = 0; 243 return ret; 244 } 245 246 247 /***************************************************************************** 248 ** 249 ** void xcb_colormap_next 250 ** 251 ** @param xcb_colormap_iterator_t *i 252 ** @returns void 253 ** 254 *****************************************************************************/ 255 256 void 257 xcb_colormap_next (xcb_colormap_iterator_t *i /**< */) 258 { 259 --i->rem; 260 ++i->data; 261 i->index += sizeof(xcb_colormap_t); 262 } 263 264 265 /***************************************************************************** 266 ** 267 ** xcb_generic_iterator_t xcb_colormap_end 268 ** 269 ** @param xcb_colormap_iterator_t i 270 ** @returns xcb_generic_iterator_t 271 ** 272 *****************************************************************************/ 273 274 xcb_generic_iterator_t 275 xcb_colormap_end (xcb_colormap_iterator_t i /**< */) 276 { 277 xcb_generic_iterator_t ret; 278 ret.data = i.data + i.rem; 279 ret.index = i.index + ((char *) ret.data - (char *) i.data); 280 ret.rem = 0; 281 return ret; 282 } 283 284 285 /***************************************************************************** 286 ** 287 ** void xcb_atom_next 288 ** 289 ** @param xcb_atom_iterator_t *i 290 ** @returns void 291 ** 292 *****************************************************************************/ 293 294 void 295 xcb_atom_next (xcb_atom_iterator_t *i /**< */) 296 { 297 --i->rem; 298 ++i->data; 299 i->index += sizeof(xcb_atom_t); 300 } 301 302 303 /***************************************************************************** 304 ** 305 ** xcb_generic_iterator_t xcb_atom_end 306 ** 307 ** @param xcb_atom_iterator_t i 308 ** @returns xcb_generic_iterator_t 309 ** 310 *****************************************************************************/ 311 312 xcb_generic_iterator_t 313 xcb_atom_end (xcb_atom_iterator_t i /**< */) 314 { 315 xcb_generic_iterator_t ret; 316 ret.data = i.data + i.rem; 317 ret.index = i.index + ((char *) ret.data - (char *) i.data); 318 ret.rem = 0; 319 return ret; 320 } 321 322 323 /***************************************************************************** 324 ** 325 ** void xcb_drawable_next 326 ** 327 ** @param xcb_drawable_iterator_t *i 328 ** @returns void 329 ** 330 *****************************************************************************/ 331 332 void 333 xcb_drawable_next (xcb_drawable_iterator_t *i /**< */) 334 { 335 --i->rem; 336 ++i->data; 337 i->index += sizeof(xcb_drawable_t); 338 } 339 340 341 /***************************************************************************** 342 ** 343 ** xcb_generic_iterator_t xcb_drawable_end 344 ** 345 ** @param xcb_drawable_iterator_t i 346 ** @returns xcb_generic_iterator_t 347 ** 348 *****************************************************************************/ 349 350 xcb_generic_iterator_t 351 xcb_drawable_end (xcb_drawable_iterator_t i /**< */) 352 { 353 xcb_generic_iterator_t ret; 354 ret.data = i.data + i.rem; 355 ret.index = i.index + ((char *) ret.data - (char *) i.data); 356 ret.rem = 0; 357 return ret; 358 } 359 360 361 /***************************************************************************** 362 ** 363 ** void xcb_fontable_next 364 ** 365 ** @param xcb_fontable_iterator_t *i 366 ** @returns void 367 ** 368 *****************************************************************************/ 369 370 void 371 xcb_fontable_next (xcb_fontable_iterator_t *i /**< */) 372 { 373 --i->rem; 374 ++i->data; 375 i->index += sizeof(xcb_fontable_t); 376 } 377 378 379 /***************************************************************************** 380 ** 381 ** xcb_generic_iterator_t xcb_fontable_end 382 ** 383 ** @param xcb_fontable_iterator_t i 384 ** @returns xcb_generic_iterator_t 385 ** 386 *****************************************************************************/ 387 388 xcb_generic_iterator_t 389 xcb_fontable_end (xcb_fontable_iterator_t i /**< */) 390 { 391 xcb_generic_iterator_t ret; 392 ret.data = i.data + i.rem; 393 ret.index = i.index + ((char *) ret.data - (char *) i.data); 394 ret.rem = 0; 395 return ret; 396 } 397 398 399 /***************************************************************************** 400 ** 401 ** void xcb_visualid_next 402 ** 403 ** @param xcb_visualid_iterator_t *i 404 ** @returns void 405 ** 406 *****************************************************************************/ 407 408 void 409 xcb_visualid_next (xcb_visualid_iterator_t *i /**< */) 410 { 411 --i->rem; 412 ++i->data; 413 i->index += sizeof(xcb_visualid_t); 414 } 415 416 417 /***************************************************************************** 418 ** 419 ** xcb_generic_iterator_t xcb_visualid_end 420 ** 421 ** @param xcb_visualid_iterator_t i 422 ** @returns xcb_generic_iterator_t 423 ** 424 *****************************************************************************/ 425 426 xcb_generic_iterator_t 427 xcb_visualid_end (xcb_visualid_iterator_t i /**< */) 428 { 429 xcb_generic_iterator_t ret; 430 ret.data = i.data + i.rem; 431 ret.index = i.index + ((char *) ret.data - (char *) i.data); 432 ret.rem = 0; 433 return ret; 434 } 435 436 437 /***************************************************************************** 438 ** 439 ** void xcb_timestamp_next 440 ** 441 ** @param xcb_timestamp_iterator_t *i 442 ** @returns void 443 ** 444 *****************************************************************************/ 445 446 void 447 xcb_timestamp_next (xcb_timestamp_iterator_t *i /**< */) 448 { 449 --i->rem; 450 ++i->data; 451 i->index += sizeof(xcb_timestamp_t); 452 } 453 454 455 /***************************************************************************** 456 ** 457 ** xcb_generic_iterator_t xcb_timestamp_end 458 ** 459 ** @param xcb_timestamp_iterator_t i 460 ** @returns xcb_generic_iterator_t 461 ** 462 *****************************************************************************/ 463 464 xcb_generic_iterator_t 465 xcb_timestamp_end (xcb_timestamp_iterator_t i /**< */) 466 { 467 xcb_generic_iterator_t ret; 468 ret.data = i.data + i.rem; 469 ret.index = i.index + ((char *) ret.data - (char *) i.data); 470 ret.rem = 0; 471 return ret; 472 } 473 474 475 /***************************************************************************** 476 ** 477 ** void xcb_keysym_next 478 ** 479 ** @param xcb_keysym_iterator_t *i 480 ** @returns void 481 ** 482 *****************************************************************************/ 483 484 void 485 xcb_keysym_next (xcb_keysym_iterator_t *i /**< */) 486 { 487 --i->rem; 488 ++i->data; 489 i->index += sizeof(xcb_keysym_t); 490 } 491 492 493 /***************************************************************************** 494 ** 495 ** xcb_generic_iterator_t xcb_keysym_end 496 ** 497 ** @param xcb_keysym_iterator_t i 498 ** @returns xcb_generic_iterator_t 499 ** 500 *****************************************************************************/ 501 502 xcb_generic_iterator_t 503 xcb_keysym_end (xcb_keysym_iterator_t i /**< */) 504 { 505 xcb_generic_iterator_t ret; 506 ret.data = i.data + i.rem; 507 ret.index = i.index + ((char *) ret.data - (char *) i.data); 508 ret.rem = 0; 509 return ret; 510 } 511 512 513 /***************************************************************************** 514 ** 515 ** void xcb_keycode_next 516 ** 517 ** @param xcb_keycode_iterator_t *i 518 ** @returns void 519 ** 520 *****************************************************************************/ 521 522 void 523 xcb_keycode_next (xcb_keycode_iterator_t *i /**< */) 524 { 525 --i->rem; 526 ++i->data; 527 i->index += sizeof(xcb_keycode_t); 528 } 529 530 531 /***************************************************************************** 532 ** 533 ** xcb_generic_iterator_t xcb_keycode_end 534 ** 535 ** @param xcb_keycode_iterator_t i 536 ** @returns xcb_generic_iterator_t 537 ** 538 *****************************************************************************/ 539 540 xcb_generic_iterator_t 541 xcb_keycode_end (xcb_keycode_iterator_t i /**< */) 542 { 543 xcb_generic_iterator_t ret; 544 ret.data = i.data + i.rem; 545 ret.index = i.index + ((char *) ret.data - (char *) i.data); 546 ret.rem = 0; 547 return ret; 548 } 549 550 551 /***************************************************************************** 552 ** 553 ** void xcb_button_next 554 ** 555 ** @param xcb_button_iterator_t *i 556 ** @returns void 557 ** 558 *****************************************************************************/ 559 560 void 561 xcb_button_next (xcb_button_iterator_t *i /**< */) 562 { 563 --i->rem; 564 ++i->data; 565 i->index += sizeof(xcb_button_t); 566 } 567 568 569 /***************************************************************************** 570 ** 571 ** xcb_generic_iterator_t xcb_button_end 572 ** 573 ** @param xcb_button_iterator_t i 574 ** @returns xcb_generic_iterator_t 575 ** 576 *****************************************************************************/ 577 578 xcb_generic_iterator_t 579 xcb_button_end (xcb_button_iterator_t i /**< */) 580 { 581 xcb_generic_iterator_t ret; 582 ret.data = i.data + i.rem; 583 ret.index = i.index + ((char *) ret.data - (char *) i.data); 584 ret.rem = 0; 585 return ret; 586 } 587 588 589 /***************************************************************************** 590 ** 591 ** void xcb_point_next 592 ** 593 ** @param xcb_point_iterator_t *i 594 ** @returns void 595 ** 596 *****************************************************************************/ 597 598 void 599 xcb_point_next (xcb_point_iterator_t *i /**< */) 600 { 601 --i->rem; 602 ++i->data; 603 i->index += sizeof(xcb_point_t); 604 } 605 606 607 /***************************************************************************** 608 ** 609 ** xcb_generic_iterator_t xcb_point_end 610 ** 611 ** @param xcb_point_iterator_t i 612 ** @returns xcb_generic_iterator_t 613 ** 614 *****************************************************************************/ 615 616 xcb_generic_iterator_t 617 xcb_point_end (xcb_point_iterator_t i /**< */) 618 { 619 xcb_generic_iterator_t ret; 620 ret.data = i.data + i.rem; 621 ret.index = i.index + ((char *) ret.data - (char *) i.data); 622 ret.rem = 0; 623 return ret; 624 } 625 626 627 /***************************************************************************** 628 ** 629 ** void xcb_rectangle_next 630 ** 631 ** @param xcb_rectangle_iterator_t *i 632 ** @returns void 633 ** 634 *****************************************************************************/ 635 636 void 637 xcb_rectangle_next (xcb_rectangle_iterator_t *i /**< */) 638 { 639 --i->rem; 640 ++i->data; 641 i->index += sizeof(xcb_rectangle_t); 642 } 643 644 645 /***************************************************************************** 646 ** 647 ** xcb_generic_iterator_t xcb_rectangle_end 648 ** 649 ** @param xcb_rectangle_iterator_t i 650 ** @returns xcb_generic_iterator_t 651 ** 652 *****************************************************************************/ 653 654 xcb_generic_iterator_t 655 xcb_rectangle_end (xcb_rectangle_iterator_t i /**< */) 656 { 657 xcb_generic_iterator_t ret; 658 ret.data = i.data + i.rem; 659 ret.index = i.index + ((char *) ret.data - (char *) i.data); 660 ret.rem = 0; 661 return ret; 662 } 663 664 665 /***************************************************************************** 666 ** 667 ** void xcb_arc_next 668 ** 669 ** @param xcb_arc_iterator_t *i 670 ** @returns void 671 ** 672 *****************************************************************************/ 673 674 void 675 xcb_arc_next (xcb_arc_iterator_t *i /**< */) 676 { 677 --i->rem; 678 ++i->data; 679 i->index += sizeof(xcb_arc_t); 680 } 681 682 683 /***************************************************************************** 684 ** 685 ** xcb_generic_iterator_t xcb_arc_end 686 ** 687 ** @param xcb_arc_iterator_t i 688 ** @returns xcb_generic_iterator_t 689 ** 690 *****************************************************************************/ 691 692 xcb_generic_iterator_t 693 xcb_arc_end (xcb_arc_iterator_t i /**< */) 694 { 695 xcb_generic_iterator_t ret; 696 ret.data = i.data + i.rem; 697 ret.index = i.index + ((char *) ret.data - (char *) i.data); 698 ret.rem = 0; 699 return ret; 700 } 701 702 703 /***************************************************************************** 704 ** 705 ** void xcb_format_next 706 ** 707 ** @param xcb_format_iterator_t *i 708 ** @returns void 709 ** 710 *****************************************************************************/ 711 712 void 713 xcb_format_next (xcb_format_iterator_t *i /**< */) 714 { 715 --i->rem; 716 ++i->data; 717 i->index += sizeof(xcb_format_t); 718 } 719 720 721 /***************************************************************************** 722 ** 723 ** xcb_generic_iterator_t xcb_format_end 724 ** 725 ** @param xcb_format_iterator_t i 726 ** @returns xcb_generic_iterator_t 727 ** 728 *****************************************************************************/ 729 730 xcb_generic_iterator_t 731 xcb_format_end (xcb_format_iterator_t i /**< */) 732 { 733 xcb_generic_iterator_t ret; 734 ret.data = i.data + i.rem; 735 ret.index = i.index + ((char *) ret.data - (char *) i.data); 736 ret.rem = 0; 737 return ret; 738 } 739 740 741 /***************************************************************************** 742 ** 743 ** void xcb_visualtype_next 744 ** 745 ** @param xcb_visualtype_iterator_t *i 746 ** @returns void 747 ** 748 *****************************************************************************/ 749 750 void 751 xcb_visualtype_next (xcb_visualtype_iterator_t *i /**< */) 752 { 753 --i->rem; 754 ++i->data; 755 i->index += sizeof(xcb_visualtype_t); 756 } 757 758 759 /***************************************************************************** 760 ** 761 ** xcb_generic_iterator_t xcb_visualtype_end 762 ** 763 ** @param xcb_visualtype_iterator_t i 764 ** @returns xcb_generic_iterator_t 765 ** 766 *****************************************************************************/ 767 768 xcb_generic_iterator_t 769 xcb_visualtype_end (xcb_visualtype_iterator_t i /**< */) 770 { 771 xcb_generic_iterator_t ret; 772 ret.data = i.data + i.rem; 773 ret.index = i.index + ((char *) ret.data - (char *) i.data); 774 ret.rem = 0; 775 return ret; 776 } 777 778 int 779 xcb_depth_sizeof (const void *_buffer /**< */) 780 { 781 char *xcb_tmp = (char *)_buffer; 782 const xcb_depth_t *_aux = (xcb_depth_t *)_buffer; 783 unsigned int xcb_buffer_len = 0; 784 unsigned int xcb_block_len = 0; 785 unsigned int xcb_pad = 0; 786 unsigned int xcb_align_to; 787 788 789 xcb_block_len += sizeof(xcb_depth_t); 790 xcb_tmp += xcb_block_len; 791 /* visuals */ 792 xcb_block_len += _aux->visuals_len * sizeof(xcb_visualtype_t); 793 xcb_tmp += xcb_block_len; 794 xcb_align_to = ALIGNOF(xcb_visualtype_t); 795 /* insert padding */ 796 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 797 xcb_buffer_len += xcb_block_len + xcb_pad; 798 if (0 != xcb_pad) { 799 xcb_tmp += xcb_pad; 800 xcb_pad = 0; 801 } 802 xcb_block_len = 0; 803 804 return xcb_buffer_len; 805 } 806 807 808 /***************************************************************************** 809 ** 810 ** xcb_visualtype_t * xcb_depth_visuals 811 ** 812 ** @param const xcb_depth_t *R 813 ** @returns xcb_visualtype_t * 814 ** 815 *****************************************************************************/ 816 817 xcb_visualtype_t * 818 xcb_depth_visuals (const xcb_depth_t *R /**< */) 819 { 820 return (xcb_visualtype_t *) (R + 1); 821 } 822 823 824 /***************************************************************************** 825 ** 826 ** int xcb_depth_visuals_length 827 ** 828 ** @param const xcb_depth_t *R 829 ** @returns int 830 ** 831 *****************************************************************************/ 832 833 int 834 xcb_depth_visuals_length (const xcb_depth_t *R /**< */) 835 { 836 return R->visuals_len; 837 } 838 839 840 /***************************************************************************** 841 ** 842 ** xcb_visualtype_iterator_t xcb_depth_visuals_iterator 843 ** 844 ** @param const xcb_depth_t *R 845 ** @returns xcb_visualtype_iterator_t 846 ** 847 *****************************************************************************/ 848 849 xcb_visualtype_iterator_t 850 xcb_depth_visuals_iterator (const xcb_depth_t *R /**< */) 851 { 852 xcb_visualtype_iterator_t i; 853 i.data = (xcb_visualtype_t *) (R + 1); 854 i.rem = R->visuals_len; 855 i.index = (char *) i.data - (char *) R; 856 return i; 857 } 858 859 860 /***************************************************************************** 861 ** 862 ** void xcb_depth_next 863 ** 864 ** @param xcb_depth_iterator_t *i 865 ** @returns void 866 ** 867 *****************************************************************************/ 868 869 void 870 xcb_depth_next (xcb_depth_iterator_t *i /**< */) 871 { 872 xcb_depth_t *R = i->data; 873 xcb_generic_iterator_t child; 874 child.data = (xcb_depth_t *)(((char *)R) + xcb_depth_sizeof(R)); 875 i->index = (char *) child.data - (char *) i->data; 876 --i->rem; 877 i->data = (xcb_depth_t *) child.data; 878 } 879 880 881 /***************************************************************************** 882 ** 883 ** xcb_generic_iterator_t xcb_depth_end 884 ** 885 ** @param xcb_depth_iterator_t i 886 ** @returns xcb_generic_iterator_t 887 ** 888 *****************************************************************************/ 889 890 xcb_generic_iterator_t 891 xcb_depth_end (xcb_depth_iterator_t i /**< */) 892 { 893 xcb_generic_iterator_t ret; 894 while(i.rem > 0) 895 xcb_depth_next(&i); 896 ret.data = i.data; 897 ret.rem = i.rem; 898 ret.index = i.index; 899 return ret; 900 } 901 902 int 903 xcb_screen_sizeof (const void *_buffer /**< */) 904 { 905 char *xcb_tmp = (char *)_buffer; 906 const xcb_screen_t *_aux = (xcb_screen_t *)_buffer; 907 unsigned int xcb_buffer_len = 0; 908 unsigned int xcb_block_len = 0; 909 unsigned int xcb_pad = 0; 910 unsigned int xcb_align_to; 911 912 unsigned int i; 913 unsigned int xcb_tmp_len; 914 915 xcb_block_len += sizeof(xcb_screen_t); 916 xcb_tmp += xcb_block_len; 917 /* allowed_depths */ 918 for(i=0; i<_aux->allowed_depths_len; i++) { 919 xcb_tmp_len = xcb_depth_sizeof(xcb_tmp); 920 xcb_block_len += xcb_tmp_len; 921 xcb_tmp += xcb_tmp_len; 922 } 923 xcb_align_to = ALIGNOF(xcb_depth_t); 924 /* insert padding */ 925 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 926 xcb_buffer_len += xcb_block_len + xcb_pad; 927 if (0 != xcb_pad) { 928 xcb_tmp += xcb_pad; 929 xcb_pad = 0; 930 } 931 xcb_block_len = 0; 932 933 return xcb_buffer_len; 934 } 935 936 937 /***************************************************************************** 938 ** 939 ** int xcb_screen_allowed_depths_length 940 ** 941 ** @param const xcb_screen_t *R 942 ** @returns int 943 ** 944 *****************************************************************************/ 945 946 int 947 xcb_screen_allowed_depths_length (const xcb_screen_t *R /**< */) 948 { 949 return R->allowed_depths_len; 950 } 951 952 953 /***************************************************************************** 954 ** 955 ** xcb_depth_iterator_t xcb_screen_allowed_depths_iterator 956 ** 957 ** @param const xcb_screen_t *R 958 ** @returns xcb_depth_iterator_t 959 ** 960 *****************************************************************************/ 961 962 xcb_depth_iterator_t 963 xcb_screen_allowed_depths_iterator (const xcb_screen_t *R /**< */) 964 { 965 xcb_depth_iterator_t i; 966 i.data = (xcb_depth_t *) (R + 1); 967 i.rem = R->allowed_depths_len; 968 i.index = (char *) i.data - (char *) R; 969 return i; 970 } 971 972 973 /***************************************************************************** 974 ** 975 ** void xcb_screen_next 976 ** 977 ** @param xcb_screen_iterator_t *i 978 ** @returns void 979 ** 980 *****************************************************************************/ 981 982 void 983 xcb_screen_next (xcb_screen_iterator_t *i /**< */) 984 { 985 xcb_screen_t *R = i->data; 986 xcb_generic_iterator_t child; 987 child.data = (xcb_screen_t *)(((char *)R) + xcb_screen_sizeof(R)); 988 i->index = (char *) child.data - (char *) i->data; 989 --i->rem; 990 i->data = (xcb_screen_t *) child.data; 991 } 992 993 994 /***************************************************************************** 995 ** 996 ** xcb_generic_iterator_t xcb_screen_end 997 ** 998 ** @param xcb_screen_iterator_t i 999 ** @returns xcb_generic_iterator_t 1000 ** 1001 *****************************************************************************/ 1002 1003 xcb_generic_iterator_t 1004 xcb_screen_end (xcb_screen_iterator_t i /**< */) 1005 { 1006 xcb_generic_iterator_t ret; 1007 while(i.rem > 0) 1008 xcb_screen_next(&i); 1009 ret.data = i.data; 1010 ret.rem = i.rem; 1011 ret.index = i.index; 1012 return ret; 1013 } 1014 1015 int 1016 xcb_setup_request_sizeof (const void *_buffer /**< */) 1017 { 1018 char *xcb_tmp = (char *)_buffer; 1019 const xcb_setup_request_t *_aux = (xcb_setup_request_t *)_buffer; 1020 unsigned int xcb_buffer_len = 0; 1021 unsigned int xcb_block_len = 0; 1022 unsigned int xcb_pad = 0; 1023 unsigned int xcb_align_to; 1024 1025 1026 xcb_block_len += sizeof(xcb_setup_request_t); 1027 xcb_tmp += xcb_block_len; 1028 /* authorization_protocol_name */ 1029 xcb_block_len += _aux->authorization_protocol_name_len * sizeof(char); 1030 xcb_tmp += xcb_block_len; 1031 xcb_align_to = ALIGNOF(char); 1032 /* insert padding */ 1033 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1034 xcb_buffer_len += xcb_block_len + xcb_pad; 1035 if (0 != xcb_pad) { 1036 xcb_tmp += xcb_pad; 1037 xcb_pad = 0; 1038 } 1039 xcb_block_len = 0; 1040 /* authorization_protocol_data */ 1041 xcb_block_len += _aux->authorization_protocol_data_len * sizeof(char); 1042 xcb_tmp += xcb_block_len; 1043 xcb_align_to = ALIGNOF(char); 1044 /* insert padding */ 1045 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1046 xcb_buffer_len += xcb_block_len + xcb_pad; 1047 if (0 != xcb_pad) { 1048 xcb_tmp += xcb_pad; 1049 xcb_pad = 0; 1050 } 1051 xcb_block_len = 0; 1052 1053 return xcb_buffer_len; 1054 } 1055 1056 1057 /***************************************************************************** 1058 ** 1059 ** char * xcb_setup_request_authorization_protocol_name 1060 ** 1061 ** @param const xcb_setup_request_t *R 1062 ** @returns char * 1063 ** 1064 *****************************************************************************/ 1065 1066 char * 1067 xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R /**< */) 1068 { 1069 return (char *) (R + 1); 1070 } 1071 1072 1073 /***************************************************************************** 1074 ** 1075 ** int xcb_setup_request_authorization_protocol_name_length 1076 ** 1077 ** @param const xcb_setup_request_t *R 1078 ** @returns int 1079 ** 1080 *****************************************************************************/ 1081 1082 int 1083 xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R /**< */) 1084 { 1085 return R->authorization_protocol_name_len; 1086 } 1087 1088 1089 /***************************************************************************** 1090 ** 1091 ** xcb_generic_iterator_t xcb_setup_request_authorization_protocol_name_end 1092 ** 1093 ** @param const xcb_setup_request_t *R 1094 ** @returns xcb_generic_iterator_t 1095 ** 1096 *****************************************************************************/ 1097 1098 xcb_generic_iterator_t 1099 xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R /**< */) 1100 { 1101 xcb_generic_iterator_t i; 1102 i.data = ((char *) (R + 1)) + (R->authorization_protocol_name_len); 1103 i.rem = 0; 1104 i.index = (char *) i.data - (char *) R; 1105 return i; 1106 } 1107 1108 1109 /***************************************************************************** 1110 ** 1111 ** char * xcb_setup_request_authorization_protocol_data 1112 ** 1113 ** @param const xcb_setup_request_t *R 1114 ** @returns char * 1115 ** 1116 *****************************************************************************/ 1117 1118 char * 1119 xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R /**< */) 1120 { 1121 xcb_generic_iterator_t prev = xcb_setup_request_authorization_protocol_name_end(R); 1122 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 1123 } 1124 1125 1126 /***************************************************************************** 1127 ** 1128 ** int xcb_setup_request_authorization_protocol_data_length 1129 ** 1130 ** @param const xcb_setup_request_t *R 1131 ** @returns int 1132 ** 1133 *****************************************************************************/ 1134 1135 int 1136 xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R /**< */) 1137 { 1138 return R->authorization_protocol_data_len; 1139 } 1140 1141 1142 /***************************************************************************** 1143 ** 1144 ** xcb_generic_iterator_t xcb_setup_request_authorization_protocol_data_end 1145 ** 1146 ** @param const xcb_setup_request_t *R 1147 ** @returns xcb_generic_iterator_t 1148 ** 1149 *****************************************************************************/ 1150 1151 xcb_generic_iterator_t 1152 xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R /**< */) 1153 { 1154 xcb_generic_iterator_t i; 1155 xcb_generic_iterator_t child = xcb_setup_request_authorization_protocol_name_end(R); 1156 i.data = ((char *) child.data) + (R->authorization_protocol_data_len); 1157 i.rem = 0; 1158 i.index = (char *) i.data - (char *) R; 1159 return i; 1160 } 1161 1162 1163 /***************************************************************************** 1164 ** 1165 ** void xcb_setup_request_next 1166 ** 1167 ** @param xcb_setup_request_iterator_t *i 1168 ** @returns void 1169 ** 1170 *****************************************************************************/ 1171 1172 void 1173 xcb_setup_request_next (xcb_setup_request_iterator_t *i /**< */) 1174 { 1175 xcb_setup_request_t *R = i->data; 1176 xcb_generic_iterator_t child; 1177 child.data = (xcb_setup_request_t *)(((char *)R) + xcb_setup_request_sizeof(R)); 1178 i->index = (char *) child.data - (char *) i->data; 1179 --i->rem; 1180 i->data = (xcb_setup_request_t *) child.data; 1181 } 1182 1183 1184 /***************************************************************************** 1185 ** 1186 ** xcb_generic_iterator_t xcb_setup_request_end 1187 ** 1188 ** @param xcb_setup_request_iterator_t i 1189 ** @returns xcb_generic_iterator_t 1190 ** 1191 *****************************************************************************/ 1192 1193 xcb_generic_iterator_t 1194 xcb_setup_request_end (xcb_setup_request_iterator_t i /**< */) 1195 { 1196 xcb_generic_iterator_t ret; 1197 while(i.rem > 0) 1198 xcb_setup_request_next(&i); 1199 ret.data = i.data; 1200 ret.rem = i.rem; 1201 ret.index = i.index; 1202 return ret; 1203 } 1204 1205 int 1206 xcb_setup_failed_sizeof (const void *_buffer /**< */) 1207 { 1208 char *xcb_tmp = (char *)_buffer; 1209 const xcb_setup_failed_t *_aux = (xcb_setup_failed_t *)_buffer; 1210 unsigned int xcb_buffer_len = 0; 1211 unsigned int xcb_block_len = 0; 1212 unsigned int xcb_pad = 0; 1213 unsigned int xcb_align_to; 1214 1215 1216 xcb_block_len += sizeof(xcb_setup_failed_t); 1217 xcb_tmp += xcb_block_len; 1218 /* reason */ 1219 xcb_block_len += _aux->reason_len * sizeof(char); 1220 xcb_tmp += xcb_block_len; 1221 xcb_align_to = ALIGNOF(char); 1222 /* insert padding */ 1223 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1224 xcb_buffer_len += xcb_block_len + xcb_pad; 1225 if (0 != xcb_pad) { 1226 xcb_tmp += xcb_pad; 1227 xcb_pad = 0; 1228 } 1229 xcb_block_len = 0; 1230 1231 return xcb_buffer_len; 1232 } 1233 1234 1235 /***************************************************************************** 1236 ** 1237 ** char * xcb_setup_failed_reason 1238 ** 1239 ** @param const xcb_setup_failed_t *R 1240 ** @returns char * 1241 ** 1242 *****************************************************************************/ 1243 1244 char * 1245 xcb_setup_failed_reason (const xcb_setup_failed_t *R /**< */) 1246 { 1247 return (char *) (R + 1); 1248 } 1249 1250 1251 /***************************************************************************** 1252 ** 1253 ** int xcb_setup_failed_reason_length 1254 ** 1255 ** @param const xcb_setup_failed_t *R 1256 ** @returns int 1257 ** 1258 *****************************************************************************/ 1259 1260 int 1261 xcb_setup_failed_reason_length (const xcb_setup_failed_t *R /**< */) 1262 { 1263 return R->reason_len; 1264 } 1265 1266 1267 /***************************************************************************** 1268 ** 1269 ** xcb_generic_iterator_t xcb_setup_failed_reason_end 1270 ** 1271 ** @param const xcb_setup_failed_t *R 1272 ** @returns xcb_generic_iterator_t 1273 ** 1274 *****************************************************************************/ 1275 1276 xcb_generic_iterator_t 1277 xcb_setup_failed_reason_end (const xcb_setup_failed_t *R /**< */) 1278 { 1279 xcb_generic_iterator_t i; 1280 i.data = ((char *) (R + 1)) + (R->reason_len); 1281 i.rem = 0; 1282 i.index = (char *) i.data - (char *) R; 1283 return i; 1284 } 1285 1286 1287 /***************************************************************************** 1288 ** 1289 ** void xcb_setup_failed_next 1290 ** 1291 ** @param xcb_setup_failed_iterator_t *i 1292 ** @returns void 1293 ** 1294 *****************************************************************************/ 1295 1296 void 1297 xcb_setup_failed_next (xcb_setup_failed_iterator_t *i /**< */) 1298 { 1299 xcb_setup_failed_t *R = i->data; 1300 xcb_generic_iterator_t child; 1301 child.data = (xcb_setup_failed_t *)(((char *)R) + xcb_setup_failed_sizeof(R)); 1302 i->index = (char *) child.data - (char *) i->data; 1303 --i->rem; 1304 i->data = (xcb_setup_failed_t *) child.data; 1305 } 1306 1307 1308 /***************************************************************************** 1309 ** 1310 ** xcb_generic_iterator_t xcb_setup_failed_end 1311 ** 1312 ** @param xcb_setup_failed_iterator_t i 1313 ** @returns xcb_generic_iterator_t 1314 ** 1315 *****************************************************************************/ 1316 1317 xcb_generic_iterator_t 1318 xcb_setup_failed_end (xcb_setup_failed_iterator_t i /**< */) 1319 { 1320 xcb_generic_iterator_t ret; 1321 while(i.rem > 0) 1322 xcb_setup_failed_next(&i); 1323 ret.data = i.data; 1324 ret.rem = i.rem; 1325 ret.index = i.index; 1326 return ret; 1327 } 1328 1329 int 1330 xcb_setup_authenticate_sizeof (const void *_buffer /**< */) 1331 { 1332 char *xcb_tmp = (char *)_buffer; 1333 const xcb_setup_authenticate_t *_aux = (xcb_setup_authenticate_t *)_buffer; 1334 unsigned int xcb_buffer_len = 0; 1335 unsigned int xcb_block_len = 0; 1336 unsigned int xcb_pad = 0; 1337 unsigned int xcb_align_to; 1338 1339 1340 xcb_block_len += sizeof(xcb_setup_authenticate_t); 1341 xcb_tmp += xcb_block_len; 1342 /* reason */ 1343 xcb_block_len += (_aux->length * 4) * sizeof(char); 1344 xcb_tmp += xcb_block_len; 1345 xcb_align_to = ALIGNOF(char); 1346 /* insert padding */ 1347 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1348 xcb_buffer_len += xcb_block_len + xcb_pad; 1349 if (0 != xcb_pad) { 1350 xcb_tmp += xcb_pad; 1351 xcb_pad = 0; 1352 } 1353 xcb_block_len = 0; 1354 1355 return xcb_buffer_len; 1356 } 1357 1358 1359 /***************************************************************************** 1360 ** 1361 ** char * xcb_setup_authenticate_reason 1362 ** 1363 ** @param const xcb_setup_authenticate_t *R 1364 ** @returns char * 1365 ** 1366 *****************************************************************************/ 1367 1368 char * 1369 xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R /**< */) 1370 { 1371 return (char *) (R + 1); 1372 } 1373 1374 1375 /***************************************************************************** 1376 ** 1377 ** int xcb_setup_authenticate_reason_length 1378 ** 1379 ** @param const xcb_setup_authenticate_t *R 1380 ** @returns int 1381 ** 1382 *****************************************************************************/ 1383 1384 int 1385 xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R /**< */) 1386 { 1387 return (R->length * 4); 1388 } 1389 1390 1391 /***************************************************************************** 1392 ** 1393 ** xcb_generic_iterator_t xcb_setup_authenticate_reason_end 1394 ** 1395 ** @param const xcb_setup_authenticate_t *R 1396 ** @returns xcb_generic_iterator_t 1397 ** 1398 *****************************************************************************/ 1399 1400 xcb_generic_iterator_t 1401 xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R /**< */) 1402 { 1403 xcb_generic_iterator_t i; 1404 i.data = ((char *) (R + 1)) + ((R->length * 4)); 1405 i.rem = 0; 1406 i.index = (char *) i.data - (char *) R; 1407 return i; 1408 } 1409 1410 1411 /***************************************************************************** 1412 ** 1413 ** void xcb_setup_authenticate_next 1414 ** 1415 ** @param xcb_setup_authenticate_iterator_t *i 1416 ** @returns void 1417 ** 1418 *****************************************************************************/ 1419 1420 void 1421 xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i /**< */) 1422 { 1423 xcb_setup_authenticate_t *R = i->data; 1424 xcb_generic_iterator_t child; 1425 child.data = (xcb_setup_authenticate_t *)(((char *)R) + xcb_setup_authenticate_sizeof(R)); 1426 i->index = (char *) child.data - (char *) i->data; 1427 --i->rem; 1428 i->data = (xcb_setup_authenticate_t *) child.data; 1429 } 1430 1431 1432 /***************************************************************************** 1433 ** 1434 ** xcb_generic_iterator_t xcb_setup_authenticate_end 1435 ** 1436 ** @param xcb_setup_authenticate_iterator_t i 1437 ** @returns xcb_generic_iterator_t 1438 ** 1439 *****************************************************************************/ 1440 1441 xcb_generic_iterator_t 1442 xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i /**< */) 1443 { 1444 xcb_generic_iterator_t ret; 1445 while(i.rem > 0) 1446 xcb_setup_authenticate_next(&i); 1447 ret.data = i.data; 1448 ret.rem = i.rem; 1449 ret.index = i.index; 1450 return ret; 1451 } 1452 1453 int 1454 xcb_setup_sizeof (const void *_buffer /**< */) 1455 { 1456 char *xcb_tmp = (char *)_buffer; 1457 const xcb_setup_t *_aux = (xcb_setup_t *)_buffer; 1458 unsigned int xcb_buffer_len = 0; 1459 unsigned int xcb_block_len = 0; 1460 unsigned int xcb_pad = 0; 1461 unsigned int xcb_align_to; 1462 1463 unsigned int i; 1464 unsigned int xcb_tmp_len; 1465 1466 xcb_block_len += sizeof(xcb_setup_t); 1467 xcb_tmp += xcb_block_len; 1468 /* vendor */ 1469 xcb_block_len += _aux->vendor_len * sizeof(char); 1470 xcb_tmp += xcb_block_len; 1471 xcb_align_to = ALIGNOF(char); 1472 /* insert padding */ 1473 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1474 xcb_buffer_len += xcb_block_len + xcb_pad; 1475 if (0 != xcb_pad) { 1476 xcb_tmp += xcb_pad; 1477 xcb_pad = 0; 1478 } 1479 xcb_block_len = 0; 1480 /* pixmap_formats */ 1481 xcb_block_len += _aux->pixmap_formats_len * sizeof(xcb_format_t); 1482 xcb_tmp += xcb_block_len; 1483 xcb_align_to = ALIGNOF(xcb_format_t); 1484 /* insert padding */ 1485 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1486 xcb_buffer_len += xcb_block_len + xcb_pad; 1487 if (0 != xcb_pad) { 1488 xcb_tmp += xcb_pad; 1489 xcb_pad = 0; 1490 } 1491 xcb_block_len = 0; 1492 /* roots */ 1493 for(i=0; i<_aux->roots_len; i++) { 1494 xcb_tmp_len = xcb_screen_sizeof(xcb_tmp); 1495 xcb_block_len += xcb_tmp_len; 1496 xcb_tmp += xcb_tmp_len; 1497 } 1498 xcb_align_to = ALIGNOF(xcb_screen_t); 1499 /* insert padding */ 1500 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1501 xcb_buffer_len += xcb_block_len + xcb_pad; 1502 if (0 != xcb_pad) { 1503 xcb_tmp += xcb_pad; 1504 xcb_pad = 0; 1505 } 1506 xcb_block_len = 0; 1507 1508 return xcb_buffer_len; 1509 } 1510 1511 1512 /***************************************************************************** 1513 ** 1514 ** char * xcb_setup_vendor 1515 ** 1516 ** @param const xcb_setup_t *R 1517 ** @returns char * 1518 ** 1519 *****************************************************************************/ 1520 1521 char * 1522 xcb_setup_vendor (const xcb_setup_t *R /**< */) 1523 { 1524 return (char *) (R + 1); 1525 } 1526 1527 1528 /***************************************************************************** 1529 ** 1530 ** int xcb_setup_vendor_length 1531 ** 1532 ** @param const xcb_setup_t *R 1533 ** @returns int 1534 ** 1535 *****************************************************************************/ 1536 1537 int 1538 xcb_setup_vendor_length (const xcb_setup_t *R /**< */) 1539 { 1540 return R->vendor_len; 1541 } 1542 1543 1544 /***************************************************************************** 1545 ** 1546 ** xcb_generic_iterator_t xcb_setup_vendor_end 1547 ** 1548 ** @param const xcb_setup_t *R 1549 ** @returns xcb_generic_iterator_t 1550 ** 1551 *****************************************************************************/ 1552 1553 xcb_generic_iterator_t 1554 xcb_setup_vendor_end (const xcb_setup_t *R /**< */) 1555 { 1556 xcb_generic_iterator_t i; 1557 i.data = ((char *) (R + 1)) + (R->vendor_len); 1558 i.rem = 0; 1559 i.index = (char *) i.data - (char *) R; 1560 return i; 1561 } 1562 1563 1564 /***************************************************************************** 1565 ** 1566 ** xcb_format_t * xcb_setup_pixmap_formats 1567 ** 1568 ** @param const xcb_setup_t *R 1569 ** @returns xcb_format_t * 1570 ** 1571 *****************************************************************************/ 1572 1573 xcb_format_t * 1574 xcb_setup_pixmap_formats (const xcb_setup_t *R /**< */) 1575 { 1576 xcb_generic_iterator_t prev = xcb_setup_vendor_end(R); 1577 return (xcb_format_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_format_t, prev.index) + 0); 1578 } 1579 1580 1581 /***************************************************************************** 1582 ** 1583 ** int xcb_setup_pixmap_formats_length 1584 ** 1585 ** @param const xcb_setup_t *R 1586 ** @returns int 1587 ** 1588 *****************************************************************************/ 1589 1590 int 1591 xcb_setup_pixmap_formats_length (const xcb_setup_t *R /**< */) 1592 { 1593 return R->pixmap_formats_len; 1594 } 1595 1596 1597 /***************************************************************************** 1598 ** 1599 ** xcb_format_iterator_t xcb_setup_pixmap_formats_iterator 1600 ** 1601 ** @param const xcb_setup_t *R 1602 ** @returns xcb_format_iterator_t 1603 ** 1604 *****************************************************************************/ 1605 1606 xcb_format_iterator_t 1607 xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R /**< */) 1608 { 1609 xcb_format_iterator_t i; 1610 xcb_generic_iterator_t prev = xcb_setup_vendor_end(R); 1611 i.data = (xcb_format_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_format_t, prev.index)); 1612 i.rem = R->pixmap_formats_len; 1613 i.index = (char *) i.data - (char *) R; 1614 return i; 1615 } 1616 1617 1618 /***************************************************************************** 1619 ** 1620 ** int xcb_setup_roots_length 1621 ** 1622 ** @param const xcb_setup_t *R 1623 ** @returns int 1624 ** 1625 *****************************************************************************/ 1626 1627 int 1628 xcb_setup_roots_length (const xcb_setup_t *R /**< */) 1629 { 1630 return R->roots_len; 1631 } 1632 1633 1634 /***************************************************************************** 1635 ** 1636 ** xcb_screen_iterator_t xcb_setup_roots_iterator 1637 ** 1638 ** @param const xcb_setup_t *R 1639 ** @returns xcb_screen_iterator_t 1640 ** 1641 *****************************************************************************/ 1642 1643 xcb_screen_iterator_t 1644 xcb_setup_roots_iterator (const xcb_setup_t *R /**< */) 1645 { 1646 xcb_screen_iterator_t i; 1647 xcb_generic_iterator_t prev = xcb_format_end(xcb_setup_pixmap_formats_iterator(R)); 1648 i.data = (xcb_screen_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_screen_t, prev.index)); 1649 i.rem = R->roots_len; 1650 i.index = (char *) i.data - (char *) R; 1651 return i; 1652 } 1653 1654 1655 /***************************************************************************** 1656 ** 1657 ** void xcb_setup_next 1658 ** 1659 ** @param xcb_setup_iterator_t *i 1660 ** @returns void 1661 ** 1662 *****************************************************************************/ 1663 1664 void 1665 xcb_setup_next (xcb_setup_iterator_t *i /**< */) 1666 { 1667 xcb_setup_t *R = i->data; 1668 xcb_generic_iterator_t child; 1669 child.data = (xcb_setup_t *)(((char *)R) + xcb_setup_sizeof(R)); 1670 i->index = (char *) child.data - (char *) i->data; 1671 --i->rem; 1672 i->data = (xcb_setup_t *) child.data; 1673 } 1674 1675 1676 /***************************************************************************** 1677 ** 1678 ** xcb_generic_iterator_t xcb_setup_end 1679 ** 1680 ** @param xcb_setup_iterator_t i 1681 ** @returns xcb_generic_iterator_t 1682 ** 1683 *****************************************************************************/ 1684 1685 xcb_generic_iterator_t 1686 xcb_setup_end (xcb_setup_iterator_t i /**< */) 1687 { 1688 xcb_generic_iterator_t ret; 1689 while(i.rem > 0) 1690 xcb_setup_next(&i); 1691 ret.data = i.data; 1692 ret.rem = i.rem; 1693 ret.index = i.index; 1694 return ret; 1695 } 1696 1697 1698 /***************************************************************************** 1699 ** 1700 ** void xcb_client_message_data_next 1701 ** 1702 ** @param xcb_client_message_data_iterator_t *i 1703 ** @returns void 1704 ** 1705 *****************************************************************************/ 1706 1707 void 1708 xcb_client_message_data_next (xcb_client_message_data_iterator_t *i /**< */) 1709 { 1710 --i->rem; 1711 ++i->data; 1712 i->index += sizeof(xcb_client_message_data_t); 1713 } 1714 1715 1716 /***************************************************************************** 1717 ** 1718 ** xcb_generic_iterator_t xcb_client_message_data_end 1719 ** 1720 ** @param xcb_client_message_data_iterator_t i 1721 ** @returns xcb_generic_iterator_t 1722 ** 1723 *****************************************************************************/ 1724 1725 xcb_generic_iterator_t 1726 xcb_client_message_data_end (xcb_client_message_data_iterator_t i /**< */) 1727 { 1728 xcb_generic_iterator_t ret; 1729 ret.data = i.data + i.rem; 1730 ret.index = i.index + ((char *) ret.data - (char *) i.data); 1731 ret.rem = 0; 1732 return ret; 1733 } 1734 1735 int 1736 xcb_create_window_sizeof (const void *_buffer /**< */) 1737 { 1738 char *xcb_tmp = (char *)_buffer; 1739 const xcb_create_window_request_t *_aux = (xcb_create_window_request_t *)_buffer; 1740 unsigned int xcb_buffer_len = 0; 1741 unsigned int xcb_block_len = 0; 1742 unsigned int xcb_pad = 0; 1743 unsigned int xcb_align_to; 1744 1745 1746 xcb_block_len += sizeof(xcb_create_window_request_t); 1747 xcb_tmp += xcb_block_len; 1748 /* value_list */ 1749 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 1750 xcb_tmp += xcb_block_len; 1751 xcb_align_to = ALIGNOF(uint32_t); 1752 /* insert padding */ 1753 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1754 xcb_buffer_len += xcb_block_len + xcb_pad; 1755 if (0 != xcb_pad) { 1756 xcb_tmp += xcb_pad; 1757 xcb_pad = 0; 1758 } 1759 xcb_block_len = 0; 1760 1761 return xcb_buffer_len; 1762 } 1763 1764 1765 /***************************************************************************** 1766 ** 1767 ** xcb_void_cookie_t xcb_create_window_checked 1768 ** 1769 ** @param xcb_connection_t *c 1770 ** @param uint8_t depth 1771 ** @param xcb_window_t wid 1772 ** @param xcb_window_t parent 1773 ** @param int16_t x 1774 ** @param int16_t y 1775 ** @param uint16_t width 1776 ** @param uint16_t height 1777 ** @param uint16_t border_width 1778 ** @param uint16_t _class 1779 ** @param xcb_visualid_t visual 1780 ** @param uint32_t value_mask 1781 ** @param const uint32_t *value_list 1782 ** @returns xcb_void_cookie_t 1783 ** 1784 *****************************************************************************/ 1785 1786 xcb_void_cookie_t 1787 xcb_create_window_checked (xcb_connection_t *c /**< */, 1788 uint8_t depth /**< */, 1789 xcb_window_t wid /**< */, 1790 xcb_window_t parent /**< */, 1791 int16_t x /**< */, 1792 int16_t y /**< */, 1793 uint16_t width /**< */, 1794 uint16_t height /**< */, 1795 uint16_t border_width /**< */, 1796 uint16_t _class /**< */, 1797 xcb_visualid_t visual /**< */, 1798 uint32_t value_mask /**< */, 1799 const uint32_t *value_list /**< */) 1800 { 1801 static const xcb_protocol_request_t xcb_req = { 1802 /* count */ 4, 1803 /* ext */ 0, 1804 /* opcode */ XCB_CREATE_WINDOW, 1805 /* isvoid */ 1 1806 }; 1807 1808 struct iovec xcb_parts[6]; 1809 xcb_void_cookie_t xcb_ret; 1810 xcb_create_window_request_t xcb_out; 1811 1812 xcb_out.depth = depth; 1813 xcb_out.wid = wid; 1814 xcb_out.parent = parent; 1815 xcb_out.x = x; 1816 xcb_out.y = y; 1817 xcb_out.width = width; 1818 xcb_out.height = height; 1819 xcb_out.border_width = border_width; 1820 xcb_out._class = _class; 1821 xcb_out.visual = visual; 1822 xcb_out.value_mask = value_mask; 1823 1824 xcb_parts[2].iov_base = (char *) &xcb_out; 1825 xcb_parts[2].iov_len = sizeof(xcb_out); 1826 xcb_parts[3].iov_base = 0; 1827 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1828 /* uint32_t value_list */ 1829 xcb_parts[4].iov_base = (char *) value_list; 1830 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 1831 xcb_parts[5].iov_base = 0; 1832 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1833 1834 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1835 return xcb_ret; 1836 } 1837 1838 1839 /***************************************************************************** 1840 ** 1841 ** xcb_void_cookie_t xcb_create_window 1842 ** 1843 ** @param xcb_connection_t *c 1844 ** @param uint8_t depth 1845 ** @param xcb_window_t wid 1846 ** @param xcb_window_t parent 1847 ** @param int16_t x 1848 ** @param int16_t y 1849 ** @param uint16_t width 1850 ** @param uint16_t height 1851 ** @param uint16_t border_width 1852 ** @param uint16_t _class 1853 ** @param xcb_visualid_t visual 1854 ** @param uint32_t value_mask 1855 ** @param const uint32_t *value_list 1856 ** @returns xcb_void_cookie_t 1857 ** 1858 *****************************************************************************/ 1859 1860 xcb_void_cookie_t 1861 xcb_create_window (xcb_connection_t *c /**< */, 1862 uint8_t depth /**< */, 1863 xcb_window_t wid /**< */, 1864 xcb_window_t parent /**< */, 1865 int16_t x /**< */, 1866 int16_t y /**< */, 1867 uint16_t width /**< */, 1868 uint16_t height /**< */, 1869 uint16_t border_width /**< */, 1870 uint16_t _class /**< */, 1871 xcb_visualid_t visual /**< */, 1872 uint32_t value_mask /**< */, 1873 const uint32_t *value_list /**< */) 1874 { 1875 static const xcb_protocol_request_t xcb_req = { 1876 /* count */ 4, 1877 /* ext */ 0, 1878 /* opcode */ XCB_CREATE_WINDOW, 1879 /* isvoid */ 1 1880 }; 1881 1882 struct iovec xcb_parts[6]; 1883 xcb_void_cookie_t xcb_ret; 1884 xcb_create_window_request_t xcb_out; 1885 1886 xcb_out.depth = depth; 1887 xcb_out.wid = wid; 1888 xcb_out.parent = parent; 1889 xcb_out.x = x; 1890 xcb_out.y = y; 1891 xcb_out.width = width; 1892 xcb_out.height = height; 1893 xcb_out.border_width = border_width; 1894 xcb_out._class = _class; 1895 xcb_out.visual = visual; 1896 xcb_out.value_mask = value_mask; 1897 1898 xcb_parts[2].iov_base = (char *) &xcb_out; 1899 xcb_parts[2].iov_len = sizeof(xcb_out); 1900 xcb_parts[3].iov_base = 0; 1901 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1902 /* uint32_t value_list */ 1903 xcb_parts[4].iov_base = (char *) value_list; 1904 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 1905 xcb_parts[5].iov_base = 0; 1906 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1907 1908 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1909 return xcb_ret; 1910 } 1911 1912 int 1913 xcb_change_window_attributes_sizeof (const void *_buffer /**< */) 1914 { 1915 char *xcb_tmp = (char *)_buffer; 1916 const xcb_change_window_attributes_request_t *_aux = (xcb_change_window_attributes_request_t *)_buffer; 1917 unsigned int xcb_buffer_len = 0; 1918 unsigned int xcb_block_len = 0; 1919 unsigned int xcb_pad = 0; 1920 unsigned int xcb_align_to; 1921 1922 1923 xcb_block_len += sizeof(xcb_change_window_attributes_request_t); 1924 xcb_tmp += xcb_block_len; 1925 /* value_list */ 1926 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 1927 xcb_tmp += xcb_block_len; 1928 xcb_align_to = ALIGNOF(uint32_t); 1929 /* insert padding */ 1930 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1931 xcb_buffer_len += xcb_block_len + xcb_pad; 1932 if (0 != xcb_pad) { 1933 xcb_tmp += xcb_pad; 1934 xcb_pad = 0; 1935 } 1936 xcb_block_len = 0; 1937 1938 return xcb_buffer_len; 1939 } 1940 1941 1942 /***************************************************************************** 1943 ** 1944 ** xcb_void_cookie_t xcb_change_window_attributes_checked 1945 ** 1946 ** @param xcb_connection_t *c 1947 ** @param xcb_window_t window 1948 ** @param uint32_t value_mask 1949 ** @param const uint32_t *value_list 1950 ** @returns xcb_void_cookie_t 1951 ** 1952 *****************************************************************************/ 1953 1954 xcb_void_cookie_t 1955 xcb_change_window_attributes_checked (xcb_connection_t *c /**< */, 1956 xcb_window_t window /**< */, 1957 uint32_t value_mask /**< */, 1958 const uint32_t *value_list /**< */) 1959 { 1960 static const xcb_protocol_request_t xcb_req = { 1961 /* count */ 4, 1962 /* ext */ 0, 1963 /* opcode */ XCB_CHANGE_WINDOW_ATTRIBUTES, 1964 /* isvoid */ 1 1965 }; 1966 1967 struct iovec xcb_parts[6]; 1968 xcb_void_cookie_t xcb_ret; 1969 xcb_change_window_attributes_request_t xcb_out; 1970 1971 xcb_out.pad0 = 0; 1972 xcb_out.window = window; 1973 xcb_out.value_mask = value_mask; 1974 1975 xcb_parts[2].iov_base = (char *) &xcb_out; 1976 xcb_parts[2].iov_len = sizeof(xcb_out); 1977 xcb_parts[3].iov_base = 0; 1978 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1979 /* uint32_t value_list */ 1980 xcb_parts[4].iov_base = (char *) value_list; 1981 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 1982 xcb_parts[5].iov_base = 0; 1983 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1984 1985 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1986 return xcb_ret; 1987 } 1988 1989 1990 /***************************************************************************** 1991 ** 1992 ** xcb_void_cookie_t xcb_change_window_attributes 1993 ** 1994 ** @param xcb_connection_t *c 1995 ** @param xcb_window_t window 1996 ** @param uint32_t value_mask 1997 ** @param const uint32_t *value_list 1998 ** @returns xcb_void_cookie_t 1999 ** 2000 *****************************************************************************/ 2001 2002 xcb_void_cookie_t 2003 xcb_change_window_attributes (xcb_connection_t *c /**< */, 2004 xcb_window_t window /**< */, 2005 uint32_t value_mask /**< */, 2006 const uint32_t *value_list /**< */) 2007 { 2008 static const xcb_protocol_request_t xcb_req = { 2009 /* count */ 4, 2010 /* ext */ 0, 2011 /* opcode */ XCB_CHANGE_WINDOW_ATTRIBUTES, 2012 /* isvoid */ 1 2013 }; 2014 2015 struct iovec xcb_parts[6]; 2016 xcb_void_cookie_t xcb_ret; 2017 xcb_change_window_attributes_request_t xcb_out; 2018 2019 xcb_out.pad0 = 0; 2020 xcb_out.window = window; 2021 xcb_out.value_mask = value_mask; 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 /* uint32_t value_list */ 2028 xcb_parts[4].iov_base = (char *) value_list; 2029 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 2030 xcb_parts[5].iov_base = 0; 2031 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2032 2033 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2034 return xcb_ret; 2035 } 2036 2037 2038 /***************************************************************************** 2039 ** 2040 ** xcb_get_window_attributes_cookie_t xcb_get_window_attributes 2041 ** 2042 ** @param xcb_connection_t *c 2043 ** @param xcb_window_t window 2044 ** @returns xcb_get_window_attributes_cookie_t 2045 ** 2046 *****************************************************************************/ 2047 2048 xcb_get_window_attributes_cookie_t 2049 xcb_get_window_attributes (xcb_connection_t *c /**< */, 2050 xcb_window_t window /**< */) 2051 { 2052 static const xcb_protocol_request_t xcb_req = { 2053 /* count */ 2, 2054 /* ext */ 0, 2055 /* opcode */ XCB_GET_WINDOW_ATTRIBUTES, 2056 /* isvoid */ 0 2057 }; 2058 2059 struct iovec xcb_parts[4]; 2060 xcb_get_window_attributes_cookie_t xcb_ret; 2061 xcb_get_window_attributes_request_t xcb_out; 2062 2063 xcb_out.pad0 = 0; 2064 xcb_out.window = window; 2065 2066 xcb_parts[2].iov_base = (char *) &xcb_out; 2067 xcb_parts[2].iov_len = sizeof(xcb_out); 2068 xcb_parts[3].iov_base = 0; 2069 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2070 2071 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2072 return xcb_ret; 2073 } 2074 2075 2076 /***************************************************************************** 2077 ** 2078 ** xcb_get_window_attributes_cookie_t xcb_get_window_attributes_unchecked 2079 ** 2080 ** @param xcb_connection_t *c 2081 ** @param xcb_window_t window 2082 ** @returns xcb_get_window_attributes_cookie_t 2083 ** 2084 *****************************************************************************/ 2085 2086 xcb_get_window_attributes_cookie_t 2087 xcb_get_window_attributes_unchecked (xcb_connection_t *c /**< */, 2088 xcb_window_t window /**< */) 2089 { 2090 static const xcb_protocol_request_t xcb_req = { 2091 /* count */ 2, 2092 /* ext */ 0, 2093 /* opcode */ XCB_GET_WINDOW_ATTRIBUTES, 2094 /* isvoid */ 0 2095 }; 2096 2097 struct iovec xcb_parts[4]; 2098 xcb_get_window_attributes_cookie_t xcb_ret; 2099 xcb_get_window_attributes_request_t xcb_out; 2100 2101 xcb_out.pad0 = 0; 2102 xcb_out.window = window; 2103 2104 xcb_parts[2].iov_base = (char *) &xcb_out; 2105 xcb_parts[2].iov_len = sizeof(xcb_out); 2106 xcb_parts[3].iov_base = 0; 2107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2108 2109 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2110 return xcb_ret; 2111 } 2112 2113 2114 /***************************************************************************** 2115 ** 2116 ** xcb_get_window_attributes_reply_t * xcb_get_window_attributes_reply 2117 ** 2118 ** @param xcb_connection_t *c 2119 ** @param xcb_get_window_attributes_cookie_t cookie 2120 ** @param xcb_generic_error_t **e 2121 ** @returns xcb_get_window_attributes_reply_t * 2122 ** 2123 *****************************************************************************/ 2124 2125 xcb_get_window_attributes_reply_t * 2126 xcb_get_window_attributes_reply (xcb_connection_t *c /**< */, 2127 xcb_get_window_attributes_cookie_t cookie /**< */, 2128 xcb_generic_error_t **e /**< */) 2129 { 2130 return (xcb_get_window_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2131 } 2132 2133 2134 /***************************************************************************** 2135 ** 2136 ** xcb_void_cookie_t xcb_destroy_window_checked 2137 ** 2138 ** @param xcb_connection_t *c 2139 ** @param xcb_window_t window 2140 ** @returns xcb_void_cookie_t 2141 ** 2142 *****************************************************************************/ 2143 2144 xcb_void_cookie_t 2145 xcb_destroy_window_checked (xcb_connection_t *c /**< */, 2146 xcb_window_t window /**< */) 2147 { 2148 static const xcb_protocol_request_t xcb_req = { 2149 /* count */ 2, 2150 /* ext */ 0, 2151 /* opcode */ XCB_DESTROY_WINDOW, 2152 /* isvoid */ 1 2153 }; 2154 2155 struct iovec xcb_parts[4]; 2156 xcb_void_cookie_t xcb_ret; 2157 xcb_destroy_window_request_t xcb_out; 2158 2159 xcb_out.pad0 = 0; 2160 xcb_out.window = window; 2161 2162 xcb_parts[2].iov_base = (char *) &xcb_out; 2163 xcb_parts[2].iov_len = sizeof(xcb_out); 2164 xcb_parts[3].iov_base = 0; 2165 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2166 2167 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2168 return xcb_ret; 2169 } 2170 2171 2172 /***************************************************************************** 2173 ** 2174 ** xcb_void_cookie_t xcb_destroy_window 2175 ** 2176 ** @param xcb_connection_t *c 2177 ** @param xcb_window_t window 2178 ** @returns xcb_void_cookie_t 2179 ** 2180 *****************************************************************************/ 2181 2182 xcb_void_cookie_t 2183 xcb_destroy_window (xcb_connection_t *c /**< */, 2184 xcb_window_t window /**< */) 2185 { 2186 static const xcb_protocol_request_t xcb_req = { 2187 /* count */ 2, 2188 /* ext */ 0, 2189 /* opcode */ XCB_DESTROY_WINDOW, 2190 /* isvoid */ 1 2191 }; 2192 2193 struct iovec xcb_parts[4]; 2194 xcb_void_cookie_t xcb_ret; 2195 xcb_destroy_window_request_t xcb_out; 2196 2197 xcb_out.pad0 = 0; 2198 xcb_out.window = window; 2199 2200 xcb_parts[2].iov_base = (char *) &xcb_out; 2201 xcb_parts[2].iov_len = sizeof(xcb_out); 2202 xcb_parts[3].iov_base = 0; 2203 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2204 2205 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2206 return xcb_ret; 2207 } 2208 2209 2210 /***************************************************************************** 2211 ** 2212 ** xcb_void_cookie_t xcb_destroy_subwindows_checked 2213 ** 2214 ** @param xcb_connection_t *c 2215 ** @param xcb_window_t window 2216 ** @returns xcb_void_cookie_t 2217 ** 2218 *****************************************************************************/ 2219 2220 xcb_void_cookie_t 2221 xcb_destroy_subwindows_checked (xcb_connection_t *c /**< */, 2222 xcb_window_t window /**< */) 2223 { 2224 static const xcb_protocol_request_t xcb_req = { 2225 /* count */ 2, 2226 /* ext */ 0, 2227 /* opcode */ XCB_DESTROY_SUBWINDOWS, 2228 /* isvoid */ 1 2229 }; 2230 2231 struct iovec xcb_parts[4]; 2232 xcb_void_cookie_t xcb_ret; 2233 xcb_destroy_subwindows_request_t xcb_out; 2234 2235 xcb_out.pad0 = 0; 2236 xcb_out.window = window; 2237 2238 xcb_parts[2].iov_base = (char *) &xcb_out; 2239 xcb_parts[2].iov_len = sizeof(xcb_out); 2240 xcb_parts[3].iov_base = 0; 2241 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2242 2243 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2244 return xcb_ret; 2245 } 2246 2247 2248 /***************************************************************************** 2249 ** 2250 ** xcb_void_cookie_t xcb_destroy_subwindows 2251 ** 2252 ** @param xcb_connection_t *c 2253 ** @param xcb_window_t window 2254 ** @returns xcb_void_cookie_t 2255 ** 2256 *****************************************************************************/ 2257 2258 xcb_void_cookie_t 2259 xcb_destroy_subwindows (xcb_connection_t *c /**< */, 2260 xcb_window_t window /**< */) 2261 { 2262 static const xcb_protocol_request_t xcb_req = { 2263 /* count */ 2, 2264 /* ext */ 0, 2265 /* opcode */ XCB_DESTROY_SUBWINDOWS, 2266 /* isvoid */ 1 2267 }; 2268 2269 struct iovec xcb_parts[4]; 2270 xcb_void_cookie_t xcb_ret; 2271 xcb_destroy_subwindows_request_t xcb_out; 2272 2273 xcb_out.pad0 = 0; 2274 xcb_out.window = window; 2275 2276 xcb_parts[2].iov_base = (char *) &xcb_out; 2277 xcb_parts[2].iov_len = sizeof(xcb_out); 2278 xcb_parts[3].iov_base = 0; 2279 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2280 2281 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2282 return xcb_ret; 2283 } 2284 2285 2286 /***************************************************************************** 2287 ** 2288 ** xcb_void_cookie_t xcb_change_save_set_checked 2289 ** 2290 ** @param xcb_connection_t *c 2291 ** @param uint8_t mode 2292 ** @param xcb_window_t window 2293 ** @returns xcb_void_cookie_t 2294 ** 2295 *****************************************************************************/ 2296 2297 xcb_void_cookie_t 2298 xcb_change_save_set_checked (xcb_connection_t *c /**< */, 2299 uint8_t mode /**< */, 2300 xcb_window_t window /**< */) 2301 { 2302 static const xcb_protocol_request_t xcb_req = { 2303 /* count */ 2, 2304 /* ext */ 0, 2305 /* opcode */ XCB_CHANGE_SAVE_SET, 2306 /* isvoid */ 1 2307 }; 2308 2309 struct iovec xcb_parts[4]; 2310 xcb_void_cookie_t xcb_ret; 2311 xcb_change_save_set_request_t xcb_out; 2312 2313 xcb_out.mode = mode; 2314 xcb_out.window = window; 2315 2316 xcb_parts[2].iov_base = (char *) &xcb_out; 2317 xcb_parts[2].iov_len = sizeof(xcb_out); 2318 xcb_parts[3].iov_base = 0; 2319 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2320 2321 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2322 return xcb_ret; 2323 } 2324 2325 2326 /***************************************************************************** 2327 ** 2328 ** xcb_void_cookie_t xcb_change_save_set 2329 ** 2330 ** @param xcb_connection_t *c 2331 ** @param uint8_t mode 2332 ** @param xcb_window_t window 2333 ** @returns xcb_void_cookie_t 2334 ** 2335 *****************************************************************************/ 2336 2337 xcb_void_cookie_t 2338 xcb_change_save_set (xcb_connection_t *c /**< */, 2339 uint8_t mode /**< */, 2340 xcb_window_t window /**< */) 2341 { 2342 static const xcb_protocol_request_t xcb_req = { 2343 /* count */ 2, 2344 /* ext */ 0, 2345 /* opcode */ XCB_CHANGE_SAVE_SET, 2346 /* isvoid */ 1 2347 }; 2348 2349 struct iovec xcb_parts[4]; 2350 xcb_void_cookie_t xcb_ret; 2351 xcb_change_save_set_request_t xcb_out; 2352 2353 xcb_out.mode = mode; 2354 xcb_out.window = window; 2355 2356 xcb_parts[2].iov_base = (char *) &xcb_out; 2357 xcb_parts[2].iov_len = sizeof(xcb_out); 2358 xcb_parts[3].iov_base = 0; 2359 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2360 2361 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2362 return xcb_ret; 2363 } 2364 2365 2366 /***************************************************************************** 2367 ** 2368 ** xcb_void_cookie_t xcb_reparent_window_checked 2369 ** 2370 ** @param xcb_connection_t *c 2371 ** @param xcb_window_t window 2372 ** @param xcb_window_t parent 2373 ** @param int16_t x 2374 ** @param int16_t y 2375 ** @returns xcb_void_cookie_t 2376 ** 2377 *****************************************************************************/ 2378 2379 xcb_void_cookie_t 2380 xcb_reparent_window_checked (xcb_connection_t *c /**< */, 2381 xcb_window_t window /**< */, 2382 xcb_window_t parent /**< */, 2383 int16_t x /**< */, 2384 int16_t y /**< */) 2385 { 2386 static const xcb_protocol_request_t xcb_req = { 2387 /* count */ 2, 2388 /* ext */ 0, 2389 /* opcode */ XCB_REPARENT_WINDOW, 2390 /* isvoid */ 1 2391 }; 2392 2393 struct iovec xcb_parts[4]; 2394 xcb_void_cookie_t xcb_ret; 2395 xcb_reparent_window_request_t xcb_out; 2396 2397 xcb_out.pad0 = 0; 2398 xcb_out.window = window; 2399 xcb_out.parent = parent; 2400 xcb_out.x = x; 2401 xcb_out.y = y; 2402 2403 xcb_parts[2].iov_base = (char *) &xcb_out; 2404 xcb_parts[2].iov_len = sizeof(xcb_out); 2405 xcb_parts[3].iov_base = 0; 2406 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2407 2408 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2409 return xcb_ret; 2410 } 2411 2412 2413 /***************************************************************************** 2414 ** 2415 ** xcb_void_cookie_t xcb_reparent_window 2416 ** 2417 ** @param xcb_connection_t *c 2418 ** @param xcb_window_t window 2419 ** @param xcb_window_t parent 2420 ** @param int16_t x 2421 ** @param int16_t y 2422 ** @returns xcb_void_cookie_t 2423 ** 2424 *****************************************************************************/ 2425 2426 xcb_void_cookie_t 2427 xcb_reparent_window (xcb_connection_t *c /**< */, 2428 xcb_window_t window /**< */, 2429 xcb_window_t parent /**< */, 2430 int16_t x /**< */, 2431 int16_t y /**< */) 2432 { 2433 static const xcb_protocol_request_t xcb_req = { 2434 /* count */ 2, 2435 /* ext */ 0, 2436 /* opcode */ XCB_REPARENT_WINDOW, 2437 /* isvoid */ 1 2438 }; 2439 2440 struct iovec xcb_parts[4]; 2441 xcb_void_cookie_t xcb_ret; 2442 xcb_reparent_window_request_t xcb_out; 2443 2444 xcb_out.pad0 = 0; 2445 xcb_out.window = window; 2446 xcb_out.parent = parent; 2447 xcb_out.x = x; 2448 xcb_out.y = y; 2449 2450 xcb_parts[2].iov_base = (char *) &xcb_out; 2451 xcb_parts[2].iov_len = sizeof(xcb_out); 2452 xcb_parts[3].iov_base = 0; 2453 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2454 2455 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2456 return xcb_ret; 2457 } 2458 2459 2460 /***************************************************************************** 2461 ** 2462 ** xcb_void_cookie_t xcb_map_window_checked 2463 ** 2464 ** @param xcb_connection_t *c 2465 ** @param xcb_window_t window 2466 ** @returns xcb_void_cookie_t 2467 ** 2468 *****************************************************************************/ 2469 2470 xcb_void_cookie_t 2471 xcb_map_window_checked (xcb_connection_t *c /**< */, 2472 xcb_window_t window /**< */) 2473 { 2474 static const xcb_protocol_request_t xcb_req = { 2475 /* count */ 2, 2476 /* ext */ 0, 2477 /* opcode */ XCB_MAP_WINDOW, 2478 /* isvoid */ 1 2479 }; 2480 2481 struct iovec xcb_parts[4]; 2482 xcb_void_cookie_t xcb_ret; 2483 xcb_map_window_request_t xcb_out; 2484 2485 xcb_out.pad0 = 0; 2486 xcb_out.window = window; 2487 2488 xcb_parts[2].iov_base = (char *) &xcb_out; 2489 xcb_parts[2].iov_len = sizeof(xcb_out); 2490 xcb_parts[3].iov_base = 0; 2491 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2492 2493 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2494 return xcb_ret; 2495 } 2496 2497 2498 /***************************************************************************** 2499 ** 2500 ** xcb_void_cookie_t xcb_map_window 2501 ** 2502 ** @param xcb_connection_t *c 2503 ** @param xcb_window_t window 2504 ** @returns xcb_void_cookie_t 2505 ** 2506 *****************************************************************************/ 2507 2508 xcb_void_cookie_t 2509 xcb_map_window (xcb_connection_t *c /**< */, 2510 xcb_window_t window /**< */) 2511 { 2512 static const xcb_protocol_request_t xcb_req = { 2513 /* count */ 2, 2514 /* ext */ 0, 2515 /* opcode */ XCB_MAP_WINDOW, 2516 /* isvoid */ 1 2517 }; 2518 2519 struct iovec xcb_parts[4]; 2520 xcb_void_cookie_t xcb_ret; 2521 xcb_map_window_request_t xcb_out; 2522 2523 xcb_out.pad0 = 0; 2524 xcb_out.window = window; 2525 2526 xcb_parts[2].iov_base = (char *) &xcb_out; 2527 xcb_parts[2].iov_len = sizeof(xcb_out); 2528 xcb_parts[3].iov_base = 0; 2529 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2530 2531 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2532 return xcb_ret; 2533 } 2534 2535 2536 /***************************************************************************** 2537 ** 2538 ** xcb_void_cookie_t xcb_map_subwindows_checked 2539 ** 2540 ** @param xcb_connection_t *c 2541 ** @param xcb_window_t window 2542 ** @returns xcb_void_cookie_t 2543 ** 2544 *****************************************************************************/ 2545 2546 xcb_void_cookie_t 2547 xcb_map_subwindows_checked (xcb_connection_t *c /**< */, 2548 xcb_window_t window /**< */) 2549 { 2550 static const xcb_protocol_request_t xcb_req = { 2551 /* count */ 2, 2552 /* ext */ 0, 2553 /* opcode */ XCB_MAP_SUBWINDOWS, 2554 /* isvoid */ 1 2555 }; 2556 2557 struct iovec xcb_parts[4]; 2558 xcb_void_cookie_t xcb_ret; 2559 xcb_map_subwindows_request_t xcb_out; 2560 2561 xcb_out.pad0 = 0; 2562 xcb_out.window = window; 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 2569 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2570 return xcb_ret; 2571 } 2572 2573 2574 /***************************************************************************** 2575 ** 2576 ** xcb_void_cookie_t xcb_map_subwindows 2577 ** 2578 ** @param xcb_connection_t *c 2579 ** @param xcb_window_t window 2580 ** @returns xcb_void_cookie_t 2581 ** 2582 *****************************************************************************/ 2583 2584 xcb_void_cookie_t 2585 xcb_map_subwindows (xcb_connection_t *c /**< */, 2586 xcb_window_t window /**< */) 2587 { 2588 static const xcb_protocol_request_t xcb_req = { 2589 /* count */ 2, 2590 /* ext */ 0, 2591 /* opcode */ XCB_MAP_SUBWINDOWS, 2592 /* isvoid */ 1 2593 }; 2594 2595 struct iovec xcb_parts[4]; 2596 xcb_void_cookie_t xcb_ret; 2597 xcb_map_subwindows_request_t xcb_out; 2598 2599 xcb_out.pad0 = 0; 2600 xcb_out.window = window; 2601 2602 xcb_parts[2].iov_base = (char *) &xcb_out; 2603 xcb_parts[2].iov_len = sizeof(xcb_out); 2604 xcb_parts[3].iov_base = 0; 2605 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2606 2607 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2608 return xcb_ret; 2609 } 2610 2611 2612 /***************************************************************************** 2613 ** 2614 ** xcb_void_cookie_t xcb_unmap_window_checked 2615 ** 2616 ** @param xcb_connection_t *c 2617 ** @param xcb_window_t window 2618 ** @returns xcb_void_cookie_t 2619 ** 2620 *****************************************************************************/ 2621 2622 xcb_void_cookie_t 2623 xcb_unmap_window_checked (xcb_connection_t *c /**< */, 2624 xcb_window_t window /**< */) 2625 { 2626 static const xcb_protocol_request_t xcb_req = { 2627 /* count */ 2, 2628 /* ext */ 0, 2629 /* opcode */ XCB_UNMAP_WINDOW, 2630 /* isvoid */ 1 2631 }; 2632 2633 struct iovec xcb_parts[4]; 2634 xcb_void_cookie_t xcb_ret; 2635 xcb_unmap_window_request_t xcb_out; 2636 2637 xcb_out.pad0 = 0; 2638 xcb_out.window = window; 2639 2640 xcb_parts[2].iov_base = (char *) &xcb_out; 2641 xcb_parts[2].iov_len = sizeof(xcb_out); 2642 xcb_parts[3].iov_base = 0; 2643 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2644 2645 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2646 return xcb_ret; 2647 } 2648 2649 2650 /***************************************************************************** 2651 ** 2652 ** xcb_void_cookie_t xcb_unmap_window 2653 ** 2654 ** @param xcb_connection_t *c 2655 ** @param xcb_window_t window 2656 ** @returns xcb_void_cookie_t 2657 ** 2658 *****************************************************************************/ 2659 2660 xcb_void_cookie_t 2661 xcb_unmap_window (xcb_connection_t *c /**< */, 2662 xcb_window_t window /**< */) 2663 { 2664 static const xcb_protocol_request_t xcb_req = { 2665 /* count */ 2, 2666 /* ext */ 0, 2667 /* opcode */ XCB_UNMAP_WINDOW, 2668 /* isvoid */ 1 2669 }; 2670 2671 struct iovec xcb_parts[4]; 2672 xcb_void_cookie_t xcb_ret; 2673 xcb_unmap_window_request_t xcb_out; 2674 2675 xcb_out.pad0 = 0; 2676 xcb_out.window = window; 2677 2678 xcb_parts[2].iov_base = (char *) &xcb_out; 2679 xcb_parts[2].iov_len = sizeof(xcb_out); 2680 xcb_parts[3].iov_base = 0; 2681 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2682 2683 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2684 return xcb_ret; 2685 } 2686 2687 2688 /***************************************************************************** 2689 ** 2690 ** xcb_void_cookie_t xcb_unmap_subwindows_checked 2691 ** 2692 ** @param xcb_connection_t *c 2693 ** @param xcb_window_t window 2694 ** @returns xcb_void_cookie_t 2695 ** 2696 *****************************************************************************/ 2697 2698 xcb_void_cookie_t 2699 xcb_unmap_subwindows_checked (xcb_connection_t *c /**< */, 2700 xcb_window_t window /**< */) 2701 { 2702 static const xcb_protocol_request_t xcb_req = { 2703 /* count */ 2, 2704 /* ext */ 0, 2705 /* opcode */ XCB_UNMAP_SUBWINDOWS, 2706 /* isvoid */ 1 2707 }; 2708 2709 struct iovec xcb_parts[4]; 2710 xcb_void_cookie_t xcb_ret; 2711 xcb_unmap_subwindows_request_t xcb_out; 2712 2713 xcb_out.pad0 = 0; 2714 xcb_out.window = window; 2715 2716 xcb_parts[2].iov_base = (char *) &xcb_out; 2717 xcb_parts[2].iov_len = sizeof(xcb_out); 2718 xcb_parts[3].iov_base = 0; 2719 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2720 2721 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2722 return xcb_ret; 2723 } 2724 2725 2726 /***************************************************************************** 2727 ** 2728 ** xcb_void_cookie_t xcb_unmap_subwindows 2729 ** 2730 ** @param xcb_connection_t *c 2731 ** @param xcb_window_t window 2732 ** @returns xcb_void_cookie_t 2733 ** 2734 *****************************************************************************/ 2735 2736 xcb_void_cookie_t 2737 xcb_unmap_subwindows (xcb_connection_t *c /**< */, 2738 xcb_window_t window /**< */) 2739 { 2740 static const xcb_protocol_request_t xcb_req = { 2741 /* count */ 2, 2742 /* ext */ 0, 2743 /* opcode */ XCB_UNMAP_SUBWINDOWS, 2744 /* isvoid */ 1 2745 }; 2746 2747 struct iovec xcb_parts[4]; 2748 xcb_void_cookie_t xcb_ret; 2749 xcb_unmap_subwindows_request_t xcb_out; 2750 2751 xcb_out.pad0 = 0; 2752 xcb_out.window = window; 2753 2754 xcb_parts[2].iov_base = (char *) &xcb_out; 2755 xcb_parts[2].iov_len = sizeof(xcb_out); 2756 xcb_parts[3].iov_base = 0; 2757 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2758 2759 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2760 return xcb_ret; 2761 } 2762 2763 int 2764 xcb_configure_window_sizeof (const void *_buffer /**< */) 2765 { 2766 char *xcb_tmp = (char *)_buffer; 2767 const xcb_configure_window_request_t *_aux = (xcb_configure_window_request_t *)_buffer; 2768 unsigned int xcb_buffer_len = 0; 2769 unsigned int xcb_block_len = 0; 2770 unsigned int xcb_pad = 0; 2771 unsigned int xcb_align_to; 2772 2773 2774 xcb_block_len += sizeof(xcb_configure_window_request_t); 2775 xcb_tmp += xcb_block_len; 2776 /* value_list */ 2777 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 2778 xcb_tmp += xcb_block_len; 2779 xcb_align_to = ALIGNOF(uint32_t); 2780 /* insert padding */ 2781 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2782 xcb_buffer_len += xcb_block_len + xcb_pad; 2783 if (0 != xcb_pad) { 2784 xcb_tmp += xcb_pad; 2785 xcb_pad = 0; 2786 } 2787 xcb_block_len = 0; 2788 2789 return xcb_buffer_len; 2790 } 2791 2792 2793 /***************************************************************************** 2794 ** 2795 ** xcb_void_cookie_t xcb_configure_window_checked 2796 ** 2797 ** @param xcb_connection_t *c 2798 ** @param xcb_window_t window 2799 ** @param uint16_t value_mask 2800 ** @param const uint32_t *value_list 2801 ** @returns xcb_void_cookie_t 2802 ** 2803 *****************************************************************************/ 2804 2805 xcb_void_cookie_t 2806 xcb_configure_window_checked (xcb_connection_t *c /**< */, 2807 xcb_window_t window /**< */, 2808 uint16_t value_mask /**< */, 2809 const uint32_t *value_list /**< */) 2810 { 2811 static const xcb_protocol_request_t xcb_req = { 2812 /* count */ 4, 2813 /* ext */ 0, 2814 /* opcode */ XCB_CONFIGURE_WINDOW, 2815 /* isvoid */ 1 2816 }; 2817 2818 struct iovec xcb_parts[6]; 2819 xcb_void_cookie_t xcb_ret; 2820 xcb_configure_window_request_t xcb_out; 2821 2822 xcb_out.pad0 = 0; 2823 xcb_out.window = window; 2824 xcb_out.value_mask = value_mask; 2825 memset(xcb_out.pad1, 0, 2); 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 /* uint32_t value_list */ 2832 xcb_parts[4].iov_base = (char *) value_list; 2833 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 2834 xcb_parts[5].iov_base = 0; 2835 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2836 2837 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2838 return xcb_ret; 2839 } 2840 2841 2842 /***************************************************************************** 2843 ** 2844 ** xcb_void_cookie_t xcb_configure_window 2845 ** 2846 ** @param xcb_connection_t *c 2847 ** @param xcb_window_t window 2848 ** @param uint16_t value_mask 2849 ** @param const uint32_t *value_list 2850 ** @returns xcb_void_cookie_t 2851 ** 2852 *****************************************************************************/ 2853 2854 xcb_void_cookie_t 2855 xcb_configure_window (xcb_connection_t *c /**< */, 2856 xcb_window_t window /**< */, 2857 uint16_t value_mask /**< */, 2858 const uint32_t *value_list /**< */) 2859 { 2860 static const xcb_protocol_request_t xcb_req = { 2861 /* count */ 4, 2862 /* ext */ 0, 2863 /* opcode */ XCB_CONFIGURE_WINDOW, 2864 /* isvoid */ 1 2865 }; 2866 2867 struct iovec xcb_parts[6]; 2868 xcb_void_cookie_t xcb_ret; 2869 xcb_configure_window_request_t xcb_out; 2870 2871 xcb_out.pad0 = 0; 2872 xcb_out.window = window; 2873 xcb_out.value_mask = value_mask; 2874 memset(xcb_out.pad1, 0, 2); 2875 2876 xcb_parts[2].iov_base = (char *) &xcb_out; 2877 xcb_parts[2].iov_len = sizeof(xcb_out); 2878 xcb_parts[3].iov_base = 0; 2879 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2880 /* uint32_t value_list */ 2881 xcb_parts[4].iov_base = (char *) value_list; 2882 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 2883 xcb_parts[5].iov_base = 0; 2884 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2885 2886 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2887 return xcb_ret; 2888 } 2889 2890 2891 /***************************************************************************** 2892 ** 2893 ** xcb_void_cookie_t xcb_circulate_window_checked 2894 ** 2895 ** @param xcb_connection_t *c 2896 ** @param uint8_t direction 2897 ** @param xcb_window_t window 2898 ** @returns xcb_void_cookie_t 2899 ** 2900 *****************************************************************************/ 2901 2902 xcb_void_cookie_t 2903 xcb_circulate_window_checked (xcb_connection_t *c /**< */, 2904 uint8_t direction /**< */, 2905 xcb_window_t window /**< */) 2906 { 2907 static const xcb_protocol_request_t xcb_req = { 2908 /* count */ 2, 2909 /* ext */ 0, 2910 /* opcode */ XCB_CIRCULATE_WINDOW, 2911 /* isvoid */ 1 2912 }; 2913 2914 struct iovec xcb_parts[4]; 2915 xcb_void_cookie_t xcb_ret; 2916 xcb_circulate_window_request_t xcb_out; 2917 2918 xcb_out.direction = direction; 2919 xcb_out.window = window; 2920 2921 xcb_parts[2].iov_base = (char *) &xcb_out; 2922 xcb_parts[2].iov_len = sizeof(xcb_out); 2923 xcb_parts[3].iov_base = 0; 2924 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2925 2926 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2927 return xcb_ret; 2928 } 2929 2930 2931 /***************************************************************************** 2932 ** 2933 ** xcb_void_cookie_t xcb_circulate_window 2934 ** 2935 ** @param xcb_connection_t *c 2936 ** @param uint8_t direction 2937 ** @param xcb_window_t window 2938 ** @returns xcb_void_cookie_t 2939 ** 2940 *****************************************************************************/ 2941 2942 xcb_void_cookie_t 2943 xcb_circulate_window (xcb_connection_t *c /**< */, 2944 uint8_t direction /**< */, 2945 xcb_window_t window /**< */) 2946 { 2947 static const xcb_protocol_request_t xcb_req = { 2948 /* count */ 2, 2949 /* ext */ 0, 2950 /* opcode */ XCB_CIRCULATE_WINDOW, 2951 /* isvoid */ 1 2952 }; 2953 2954 struct iovec xcb_parts[4]; 2955 xcb_void_cookie_t xcb_ret; 2956 xcb_circulate_window_request_t xcb_out; 2957 2958 xcb_out.direction = direction; 2959 xcb_out.window = window; 2960 2961 xcb_parts[2].iov_base = (char *) &xcb_out; 2962 xcb_parts[2].iov_len = sizeof(xcb_out); 2963 xcb_parts[3].iov_base = 0; 2964 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2965 2966 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2967 return xcb_ret; 2968 } 2969 2970 2971 /***************************************************************************** 2972 ** 2973 ** xcb_get_geometry_cookie_t xcb_get_geometry 2974 ** 2975 ** @param xcb_connection_t *c 2976 ** @param xcb_drawable_t drawable 2977 ** @returns xcb_get_geometry_cookie_t 2978 ** 2979 *****************************************************************************/ 2980 2981 xcb_get_geometry_cookie_t 2982 xcb_get_geometry (xcb_connection_t *c /**< */, 2983 xcb_drawable_t drawable /**< */) 2984 { 2985 static const xcb_protocol_request_t xcb_req = { 2986 /* count */ 2, 2987 /* ext */ 0, 2988 /* opcode */ XCB_GET_GEOMETRY, 2989 /* isvoid */ 0 2990 }; 2991 2992 struct iovec xcb_parts[4]; 2993 xcb_get_geometry_cookie_t xcb_ret; 2994 xcb_get_geometry_request_t xcb_out; 2995 2996 xcb_out.pad0 = 0; 2997 xcb_out.drawable = drawable; 2998 2999 xcb_parts[2].iov_base = (char *) &xcb_out; 3000 xcb_parts[2].iov_len = sizeof(xcb_out); 3001 xcb_parts[3].iov_base = 0; 3002 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3003 3004 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3005 return xcb_ret; 3006 } 3007 3008 3009 /***************************************************************************** 3010 ** 3011 ** xcb_get_geometry_cookie_t xcb_get_geometry_unchecked 3012 ** 3013 ** @param xcb_connection_t *c 3014 ** @param xcb_drawable_t drawable 3015 ** @returns xcb_get_geometry_cookie_t 3016 ** 3017 *****************************************************************************/ 3018 3019 xcb_get_geometry_cookie_t 3020 xcb_get_geometry_unchecked (xcb_connection_t *c /**< */, 3021 xcb_drawable_t drawable /**< */) 3022 { 3023 static const xcb_protocol_request_t xcb_req = { 3024 /* count */ 2, 3025 /* ext */ 0, 3026 /* opcode */ XCB_GET_GEOMETRY, 3027 /* isvoid */ 0 3028 }; 3029 3030 struct iovec xcb_parts[4]; 3031 xcb_get_geometry_cookie_t xcb_ret; 3032 xcb_get_geometry_request_t xcb_out; 3033 3034 xcb_out.pad0 = 0; 3035 xcb_out.drawable = drawable; 3036 3037 xcb_parts[2].iov_base = (char *) &xcb_out; 3038 xcb_parts[2].iov_len = sizeof(xcb_out); 3039 xcb_parts[3].iov_base = 0; 3040 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3041 3042 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3043 return xcb_ret; 3044 } 3045 3046 3047 /***************************************************************************** 3048 ** 3049 ** xcb_get_geometry_reply_t * xcb_get_geometry_reply 3050 ** 3051 ** @param xcb_connection_t *c 3052 ** @param xcb_get_geometry_cookie_t cookie 3053 ** @param xcb_generic_error_t **e 3054 ** @returns xcb_get_geometry_reply_t * 3055 ** 3056 *****************************************************************************/ 3057 3058 xcb_get_geometry_reply_t * 3059 xcb_get_geometry_reply (xcb_connection_t *c /**< */, 3060 xcb_get_geometry_cookie_t cookie /**< */, 3061 xcb_generic_error_t **e /**< */) 3062 { 3063 return (xcb_get_geometry_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3064 } 3065 3066 int 3067 xcb_query_tree_sizeof (const void *_buffer /**< */) 3068 { 3069 char *xcb_tmp = (char *)_buffer; 3070 const xcb_query_tree_reply_t *_aux = (xcb_query_tree_reply_t *)_buffer; 3071 unsigned int xcb_buffer_len = 0; 3072 unsigned int xcb_block_len = 0; 3073 unsigned int xcb_pad = 0; 3074 unsigned int xcb_align_to; 3075 3076 3077 xcb_block_len += sizeof(xcb_query_tree_reply_t); 3078 xcb_tmp += xcb_block_len; 3079 /* children */ 3080 xcb_block_len += _aux->children_len * sizeof(xcb_window_t); 3081 xcb_tmp += xcb_block_len; 3082 xcb_align_to = ALIGNOF(xcb_window_t); 3083 /* insert padding */ 3084 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3085 xcb_buffer_len += xcb_block_len + xcb_pad; 3086 if (0 != xcb_pad) { 3087 xcb_tmp += xcb_pad; 3088 xcb_pad = 0; 3089 } 3090 xcb_block_len = 0; 3091 3092 return xcb_buffer_len; 3093 } 3094 3095 3096 /***************************************************************************** 3097 ** 3098 ** xcb_query_tree_cookie_t xcb_query_tree 3099 ** 3100 ** @param xcb_connection_t *c 3101 ** @param xcb_window_t window 3102 ** @returns xcb_query_tree_cookie_t 3103 ** 3104 *****************************************************************************/ 3105 3106 xcb_query_tree_cookie_t 3107 xcb_query_tree (xcb_connection_t *c /**< */, 3108 xcb_window_t window /**< */) 3109 { 3110 static const xcb_protocol_request_t xcb_req = { 3111 /* count */ 2, 3112 /* ext */ 0, 3113 /* opcode */ XCB_QUERY_TREE, 3114 /* isvoid */ 0 3115 }; 3116 3117 struct iovec xcb_parts[4]; 3118 xcb_query_tree_cookie_t xcb_ret; 3119 xcb_query_tree_request_t xcb_out; 3120 3121 xcb_out.pad0 = 0; 3122 xcb_out.window = window; 3123 3124 xcb_parts[2].iov_base = (char *) &xcb_out; 3125 xcb_parts[2].iov_len = sizeof(xcb_out); 3126 xcb_parts[3].iov_base = 0; 3127 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3128 3129 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3130 return xcb_ret; 3131 } 3132 3133 3134 /***************************************************************************** 3135 ** 3136 ** xcb_query_tree_cookie_t xcb_query_tree_unchecked 3137 ** 3138 ** @param xcb_connection_t *c 3139 ** @param xcb_window_t window 3140 ** @returns xcb_query_tree_cookie_t 3141 ** 3142 *****************************************************************************/ 3143 3144 xcb_query_tree_cookie_t 3145 xcb_query_tree_unchecked (xcb_connection_t *c /**< */, 3146 xcb_window_t window /**< */) 3147 { 3148 static const xcb_protocol_request_t xcb_req = { 3149 /* count */ 2, 3150 /* ext */ 0, 3151 /* opcode */ XCB_QUERY_TREE, 3152 /* isvoid */ 0 3153 }; 3154 3155 struct iovec xcb_parts[4]; 3156 xcb_query_tree_cookie_t xcb_ret; 3157 xcb_query_tree_request_t xcb_out; 3158 3159 xcb_out.pad0 = 0; 3160 xcb_out.window = window; 3161 3162 xcb_parts[2].iov_base = (char *) &xcb_out; 3163 xcb_parts[2].iov_len = sizeof(xcb_out); 3164 xcb_parts[3].iov_base = 0; 3165 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3166 3167 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3168 return xcb_ret; 3169 } 3170 3171 3172 /***************************************************************************** 3173 ** 3174 ** xcb_window_t * xcb_query_tree_children 3175 ** 3176 ** @param const xcb_query_tree_reply_t *R 3177 ** @returns xcb_window_t * 3178 ** 3179 *****************************************************************************/ 3180 3181 xcb_window_t * 3182 xcb_query_tree_children (const xcb_query_tree_reply_t *R /**< */) 3183 { 3184 return (xcb_window_t *) (R + 1); 3185 } 3186 3187 3188 /***************************************************************************** 3189 ** 3190 ** int xcb_query_tree_children_length 3191 ** 3192 ** @param const xcb_query_tree_reply_t *R 3193 ** @returns int 3194 ** 3195 *****************************************************************************/ 3196 3197 int 3198 xcb_query_tree_children_length (const xcb_query_tree_reply_t *R /**< */) 3199 { 3200 return R->children_len; 3201 } 3202 3203 3204 /***************************************************************************** 3205 ** 3206 ** xcb_generic_iterator_t xcb_query_tree_children_end 3207 ** 3208 ** @param const xcb_query_tree_reply_t *R 3209 ** @returns xcb_generic_iterator_t 3210 ** 3211 *****************************************************************************/ 3212 3213 xcb_generic_iterator_t 3214 xcb_query_tree_children_end (const xcb_query_tree_reply_t *R /**< */) 3215 { 3216 xcb_generic_iterator_t i; 3217 i.data = ((xcb_window_t *) (R + 1)) + (R->children_len); 3218 i.rem = 0; 3219 i.index = (char *) i.data - (char *) R; 3220 return i; 3221 } 3222 3223 3224 /***************************************************************************** 3225 ** 3226 ** xcb_query_tree_reply_t * xcb_query_tree_reply 3227 ** 3228 ** @param xcb_connection_t *c 3229 ** @param xcb_query_tree_cookie_t cookie 3230 ** @param xcb_generic_error_t **e 3231 ** @returns xcb_query_tree_reply_t * 3232 ** 3233 *****************************************************************************/ 3234 3235 xcb_query_tree_reply_t * 3236 xcb_query_tree_reply (xcb_connection_t *c /**< */, 3237 xcb_query_tree_cookie_t cookie /**< */, 3238 xcb_generic_error_t **e /**< */) 3239 { 3240 return (xcb_query_tree_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3241 } 3242 3243 int 3244 xcb_intern_atom_sizeof (const void *_buffer /**< */) 3245 { 3246 char *xcb_tmp = (char *)_buffer; 3247 const xcb_intern_atom_request_t *_aux = (xcb_intern_atom_request_t *)_buffer; 3248 unsigned int xcb_buffer_len = 0; 3249 unsigned int xcb_block_len = 0; 3250 unsigned int xcb_pad = 0; 3251 unsigned int xcb_align_to; 3252 3253 3254 xcb_block_len += sizeof(xcb_intern_atom_request_t); 3255 xcb_tmp += xcb_block_len; 3256 /* name */ 3257 xcb_block_len += _aux->name_len * sizeof(char); 3258 xcb_tmp += xcb_block_len; 3259 xcb_align_to = ALIGNOF(char); 3260 /* insert padding */ 3261 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3262 xcb_buffer_len += xcb_block_len + xcb_pad; 3263 if (0 != xcb_pad) { 3264 xcb_tmp += xcb_pad; 3265 xcb_pad = 0; 3266 } 3267 xcb_block_len = 0; 3268 3269 return xcb_buffer_len; 3270 } 3271 3272 3273 /***************************************************************************** 3274 ** 3275 ** xcb_intern_atom_cookie_t xcb_intern_atom 3276 ** 3277 ** @param xcb_connection_t *c 3278 ** @param uint8_t only_if_exists 3279 ** @param uint16_t name_len 3280 ** @param const char *name 3281 ** @returns xcb_intern_atom_cookie_t 3282 ** 3283 *****************************************************************************/ 3284 3285 xcb_intern_atom_cookie_t 3286 xcb_intern_atom (xcb_connection_t *c /**< */, 3287 uint8_t only_if_exists /**< */, 3288 uint16_t name_len /**< */, 3289 const char *name /**< */) 3290 { 3291 static const xcb_protocol_request_t xcb_req = { 3292 /* count */ 4, 3293 /* ext */ 0, 3294 /* opcode */ XCB_INTERN_ATOM, 3295 /* isvoid */ 0 3296 }; 3297 3298 struct iovec xcb_parts[6]; 3299 xcb_intern_atom_cookie_t xcb_ret; 3300 xcb_intern_atom_request_t xcb_out; 3301 3302 xcb_out.only_if_exists = only_if_exists; 3303 xcb_out.name_len = name_len; 3304 memset(xcb_out.pad0, 0, 2); 3305 3306 xcb_parts[2].iov_base = (char *) &xcb_out; 3307 xcb_parts[2].iov_len = sizeof(xcb_out); 3308 xcb_parts[3].iov_base = 0; 3309 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3310 /* char name */ 3311 xcb_parts[4].iov_base = (char *) name; 3312 xcb_parts[4].iov_len = name_len * sizeof(char); 3313 xcb_parts[5].iov_base = 0; 3314 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3315 3316 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3317 return xcb_ret; 3318 } 3319 3320 3321 /***************************************************************************** 3322 ** 3323 ** xcb_intern_atom_cookie_t xcb_intern_atom_unchecked 3324 ** 3325 ** @param xcb_connection_t *c 3326 ** @param uint8_t only_if_exists 3327 ** @param uint16_t name_len 3328 ** @param const char *name 3329 ** @returns xcb_intern_atom_cookie_t 3330 ** 3331 *****************************************************************************/ 3332 3333 xcb_intern_atom_cookie_t 3334 xcb_intern_atom_unchecked (xcb_connection_t *c /**< */, 3335 uint8_t only_if_exists /**< */, 3336 uint16_t name_len /**< */, 3337 const char *name /**< */) 3338 { 3339 static const xcb_protocol_request_t xcb_req = { 3340 /* count */ 4, 3341 /* ext */ 0, 3342 /* opcode */ XCB_INTERN_ATOM, 3343 /* isvoid */ 0 3344 }; 3345 3346 struct iovec xcb_parts[6]; 3347 xcb_intern_atom_cookie_t xcb_ret; 3348 xcb_intern_atom_request_t xcb_out; 3349 3350 xcb_out.only_if_exists = only_if_exists; 3351 xcb_out.name_len = name_len; 3352 memset(xcb_out.pad0, 0, 2); 3353 3354 xcb_parts[2].iov_base = (char *) &xcb_out; 3355 xcb_parts[2].iov_len = sizeof(xcb_out); 3356 xcb_parts[3].iov_base = 0; 3357 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3358 /* char name */ 3359 xcb_parts[4].iov_base = (char *) name; 3360 xcb_parts[4].iov_len = name_len * sizeof(char); 3361 xcb_parts[5].iov_base = 0; 3362 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3363 3364 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3365 return xcb_ret; 3366 } 3367 3368 3369 /***************************************************************************** 3370 ** 3371 ** xcb_intern_atom_reply_t * xcb_intern_atom_reply 3372 ** 3373 ** @param xcb_connection_t *c 3374 ** @param xcb_intern_atom_cookie_t cookie 3375 ** @param xcb_generic_error_t **e 3376 ** @returns xcb_intern_atom_reply_t * 3377 ** 3378 *****************************************************************************/ 3379 3380 xcb_intern_atom_reply_t * 3381 xcb_intern_atom_reply (xcb_connection_t *c /**< */, 3382 xcb_intern_atom_cookie_t cookie /**< */, 3383 xcb_generic_error_t **e /**< */) 3384 { 3385 return (xcb_intern_atom_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3386 } 3387 3388 int 3389 xcb_get_atom_name_sizeof (const void *_buffer /**< */) 3390 { 3391 char *xcb_tmp = (char *)_buffer; 3392 const xcb_get_atom_name_reply_t *_aux = (xcb_get_atom_name_reply_t *)_buffer; 3393 unsigned int xcb_buffer_len = 0; 3394 unsigned int xcb_block_len = 0; 3395 unsigned int xcb_pad = 0; 3396 unsigned int xcb_align_to; 3397 3398 3399 xcb_block_len += sizeof(xcb_get_atom_name_reply_t); 3400 xcb_tmp += xcb_block_len; 3401 /* name */ 3402 xcb_block_len += _aux->name_len * sizeof(char); 3403 xcb_tmp += xcb_block_len; 3404 xcb_align_to = ALIGNOF(char); 3405 /* insert padding */ 3406 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3407 xcb_buffer_len += xcb_block_len + xcb_pad; 3408 if (0 != xcb_pad) { 3409 xcb_tmp += xcb_pad; 3410 xcb_pad = 0; 3411 } 3412 xcb_block_len = 0; 3413 3414 return xcb_buffer_len; 3415 } 3416 3417 3418 /***************************************************************************** 3419 ** 3420 ** xcb_get_atom_name_cookie_t xcb_get_atom_name 3421 ** 3422 ** @param xcb_connection_t *c 3423 ** @param xcb_atom_t atom 3424 ** @returns xcb_get_atom_name_cookie_t 3425 ** 3426 *****************************************************************************/ 3427 3428 xcb_get_atom_name_cookie_t 3429 xcb_get_atom_name (xcb_connection_t *c /**< */, 3430 xcb_atom_t atom /**< */) 3431 { 3432 static const xcb_protocol_request_t xcb_req = { 3433 /* count */ 2, 3434 /* ext */ 0, 3435 /* opcode */ XCB_GET_ATOM_NAME, 3436 /* isvoid */ 0 3437 }; 3438 3439 struct iovec xcb_parts[4]; 3440 xcb_get_atom_name_cookie_t xcb_ret; 3441 xcb_get_atom_name_request_t xcb_out; 3442 3443 xcb_out.pad0 = 0; 3444 xcb_out.atom = atom; 3445 3446 xcb_parts[2].iov_base = (char *) &xcb_out; 3447 xcb_parts[2].iov_len = sizeof(xcb_out); 3448 xcb_parts[3].iov_base = 0; 3449 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3450 3451 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3452 return xcb_ret; 3453 } 3454 3455 3456 /***************************************************************************** 3457 ** 3458 ** xcb_get_atom_name_cookie_t xcb_get_atom_name_unchecked 3459 ** 3460 ** @param xcb_connection_t *c 3461 ** @param xcb_atom_t atom 3462 ** @returns xcb_get_atom_name_cookie_t 3463 ** 3464 *****************************************************************************/ 3465 3466 xcb_get_atom_name_cookie_t 3467 xcb_get_atom_name_unchecked (xcb_connection_t *c /**< */, 3468 xcb_atom_t atom /**< */) 3469 { 3470 static const xcb_protocol_request_t xcb_req = { 3471 /* count */ 2, 3472 /* ext */ 0, 3473 /* opcode */ XCB_GET_ATOM_NAME, 3474 /* isvoid */ 0 3475 }; 3476 3477 struct iovec xcb_parts[4]; 3478 xcb_get_atom_name_cookie_t xcb_ret; 3479 xcb_get_atom_name_request_t xcb_out; 3480 3481 xcb_out.pad0 = 0; 3482 xcb_out.atom = atom; 3483 3484 xcb_parts[2].iov_base = (char *) &xcb_out; 3485 xcb_parts[2].iov_len = sizeof(xcb_out); 3486 xcb_parts[3].iov_base = 0; 3487 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3488 3489 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3490 return xcb_ret; 3491 } 3492 3493 3494 /***************************************************************************** 3495 ** 3496 ** char * xcb_get_atom_name_name 3497 ** 3498 ** @param const xcb_get_atom_name_reply_t *R 3499 ** @returns char * 3500 ** 3501 *****************************************************************************/ 3502 3503 char * 3504 xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R /**< */) 3505 { 3506 return (char *) (R + 1); 3507 } 3508 3509 3510 /***************************************************************************** 3511 ** 3512 ** int xcb_get_atom_name_name_length 3513 ** 3514 ** @param const xcb_get_atom_name_reply_t *R 3515 ** @returns int 3516 ** 3517 *****************************************************************************/ 3518 3519 int 3520 xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R /**< */) 3521 { 3522 return R->name_len; 3523 } 3524 3525 3526 /***************************************************************************** 3527 ** 3528 ** xcb_generic_iterator_t xcb_get_atom_name_name_end 3529 ** 3530 ** @param const xcb_get_atom_name_reply_t *R 3531 ** @returns xcb_generic_iterator_t 3532 ** 3533 *****************************************************************************/ 3534 3535 xcb_generic_iterator_t 3536 xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R /**< */) 3537 { 3538 xcb_generic_iterator_t i; 3539 i.data = ((char *) (R + 1)) + (R->name_len); 3540 i.rem = 0; 3541 i.index = (char *) i.data - (char *) R; 3542 return i; 3543 } 3544 3545 3546 /***************************************************************************** 3547 ** 3548 ** xcb_get_atom_name_reply_t * xcb_get_atom_name_reply 3549 ** 3550 ** @param xcb_connection_t *c 3551 ** @param xcb_get_atom_name_cookie_t cookie 3552 ** @param xcb_generic_error_t **e 3553 ** @returns xcb_get_atom_name_reply_t * 3554 ** 3555 *****************************************************************************/ 3556 3557 xcb_get_atom_name_reply_t * 3558 xcb_get_atom_name_reply (xcb_connection_t *c /**< */, 3559 xcb_get_atom_name_cookie_t cookie /**< */, 3560 xcb_generic_error_t **e /**< */) 3561 { 3562 return (xcb_get_atom_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3563 } 3564 3565 int 3566 xcb_change_property_sizeof (const void *_buffer /**< */) 3567 { 3568 char *xcb_tmp = (char *)_buffer; 3569 const xcb_change_property_request_t *_aux = (xcb_change_property_request_t *)_buffer; 3570 unsigned int xcb_buffer_len = 0; 3571 unsigned int xcb_block_len = 0; 3572 unsigned int xcb_pad = 0; 3573 unsigned int xcb_align_to; 3574 3575 3576 xcb_block_len += sizeof(xcb_change_property_request_t); 3577 xcb_tmp += xcb_block_len; 3578 /* data */ 3579 xcb_block_len += ((_aux->data_len * _aux->format) / 8) * sizeof(char); 3580 xcb_tmp += xcb_block_len; 3581 xcb_align_to = ALIGNOF(char); 3582 /* insert padding */ 3583 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3584 xcb_buffer_len += xcb_block_len + xcb_pad; 3585 if (0 != xcb_pad) { 3586 xcb_tmp += xcb_pad; 3587 xcb_pad = 0; 3588 } 3589 xcb_block_len = 0; 3590 3591 return xcb_buffer_len; 3592 } 3593 3594 3595 /***************************************************************************** 3596 ** 3597 ** xcb_void_cookie_t xcb_change_property_checked 3598 ** 3599 ** @param xcb_connection_t *c 3600 ** @param uint8_t mode 3601 ** @param xcb_window_t window 3602 ** @param xcb_atom_t property 3603 ** @param xcb_atom_t type 3604 ** @param uint8_t format 3605 ** @param uint32_t data_len 3606 ** @param const void *data 3607 ** @returns xcb_void_cookie_t 3608 ** 3609 *****************************************************************************/ 3610 3611 xcb_void_cookie_t 3612 xcb_change_property_checked (xcb_connection_t *c /**< */, 3613 uint8_t mode /**< */, 3614 xcb_window_t window /**< */, 3615 xcb_atom_t property /**< */, 3616 xcb_atom_t type /**< */, 3617 uint8_t format /**< */, 3618 uint32_t data_len /**< */, 3619 const void *data /**< */) 3620 { 3621 static const xcb_protocol_request_t xcb_req = { 3622 /* count */ 4, 3623 /* ext */ 0, 3624 /* opcode */ XCB_CHANGE_PROPERTY, 3625 /* isvoid */ 1 3626 }; 3627 3628 struct iovec xcb_parts[6]; 3629 xcb_void_cookie_t xcb_ret; 3630 xcb_change_property_request_t xcb_out; 3631 3632 xcb_out.mode = mode; 3633 xcb_out.window = window; 3634 xcb_out.property = property; 3635 xcb_out.type = type; 3636 xcb_out.format = format; 3637 memset(xcb_out.pad0, 0, 3); 3638 xcb_out.data_len = data_len; 3639 3640 xcb_parts[2].iov_base = (char *) &xcb_out; 3641 xcb_parts[2].iov_len = sizeof(xcb_out); 3642 xcb_parts[3].iov_base = 0; 3643 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3644 /* void data */ 3645 xcb_parts[4].iov_base = (char *) data; 3646 xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char); 3647 xcb_parts[5].iov_base = 0; 3648 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3649 3650 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3651 return xcb_ret; 3652 } 3653 3654 3655 /***************************************************************************** 3656 ** 3657 ** xcb_void_cookie_t xcb_change_property 3658 ** 3659 ** @param xcb_connection_t *c 3660 ** @param uint8_t mode 3661 ** @param xcb_window_t window 3662 ** @param xcb_atom_t property 3663 ** @param xcb_atom_t type 3664 ** @param uint8_t format 3665 ** @param uint32_t data_len 3666 ** @param const void *data 3667 ** @returns xcb_void_cookie_t 3668 ** 3669 *****************************************************************************/ 3670 3671 xcb_void_cookie_t 3672 xcb_change_property (xcb_connection_t *c /**< */, 3673 uint8_t mode /**< */, 3674 xcb_window_t window /**< */, 3675 xcb_atom_t property /**< */, 3676 xcb_atom_t type /**< */, 3677 uint8_t format /**< */, 3678 uint32_t data_len /**< */, 3679 const void *data /**< */) 3680 { 3681 static const xcb_protocol_request_t xcb_req = { 3682 /* count */ 4, 3683 /* ext */ 0, 3684 /* opcode */ XCB_CHANGE_PROPERTY, 3685 /* isvoid */ 1 3686 }; 3687 3688 struct iovec xcb_parts[6]; 3689 xcb_void_cookie_t xcb_ret; 3690 xcb_change_property_request_t xcb_out; 3691 3692 xcb_out.mode = mode; 3693 xcb_out.window = window; 3694 xcb_out.property = property; 3695 xcb_out.type = type; 3696 xcb_out.format = format; 3697 memset(xcb_out.pad0, 0, 3); 3698 xcb_out.data_len = data_len; 3699 3700 xcb_parts[2].iov_base = (char *) &xcb_out; 3701 xcb_parts[2].iov_len = sizeof(xcb_out); 3702 xcb_parts[3].iov_base = 0; 3703 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3704 /* void data */ 3705 xcb_parts[4].iov_base = (char *) data; 3706 xcb_parts[4].iov_len = ((data_len * format) / 8) * sizeof(char); 3707 xcb_parts[5].iov_base = 0; 3708 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 3709 3710 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3711 return xcb_ret; 3712 } 3713 3714 3715 /***************************************************************************** 3716 ** 3717 ** xcb_void_cookie_t xcb_delete_property_checked 3718 ** 3719 ** @param xcb_connection_t *c 3720 ** @param xcb_window_t window 3721 ** @param xcb_atom_t property 3722 ** @returns xcb_void_cookie_t 3723 ** 3724 *****************************************************************************/ 3725 3726 xcb_void_cookie_t 3727 xcb_delete_property_checked (xcb_connection_t *c /**< */, 3728 xcb_window_t window /**< */, 3729 xcb_atom_t property /**< */) 3730 { 3731 static const xcb_protocol_request_t xcb_req = { 3732 /* count */ 2, 3733 /* ext */ 0, 3734 /* opcode */ XCB_DELETE_PROPERTY, 3735 /* isvoid */ 1 3736 }; 3737 3738 struct iovec xcb_parts[4]; 3739 xcb_void_cookie_t xcb_ret; 3740 xcb_delete_property_request_t xcb_out; 3741 3742 xcb_out.pad0 = 0; 3743 xcb_out.window = window; 3744 xcb_out.property = property; 3745 3746 xcb_parts[2].iov_base = (char *) &xcb_out; 3747 xcb_parts[2].iov_len = sizeof(xcb_out); 3748 xcb_parts[3].iov_base = 0; 3749 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3750 3751 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3752 return xcb_ret; 3753 } 3754 3755 3756 /***************************************************************************** 3757 ** 3758 ** xcb_void_cookie_t xcb_delete_property 3759 ** 3760 ** @param xcb_connection_t *c 3761 ** @param xcb_window_t window 3762 ** @param xcb_atom_t property 3763 ** @returns xcb_void_cookie_t 3764 ** 3765 *****************************************************************************/ 3766 3767 xcb_void_cookie_t 3768 xcb_delete_property (xcb_connection_t *c /**< */, 3769 xcb_window_t window /**< */, 3770 xcb_atom_t property /**< */) 3771 { 3772 static const xcb_protocol_request_t xcb_req = { 3773 /* count */ 2, 3774 /* ext */ 0, 3775 /* opcode */ XCB_DELETE_PROPERTY, 3776 /* isvoid */ 1 3777 }; 3778 3779 struct iovec xcb_parts[4]; 3780 xcb_void_cookie_t xcb_ret; 3781 xcb_delete_property_request_t xcb_out; 3782 3783 xcb_out.pad0 = 0; 3784 xcb_out.window = window; 3785 xcb_out.property = property; 3786 3787 xcb_parts[2].iov_base = (char *) &xcb_out; 3788 xcb_parts[2].iov_len = sizeof(xcb_out); 3789 xcb_parts[3].iov_base = 0; 3790 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3791 3792 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3793 return xcb_ret; 3794 } 3795 3796 int 3797 xcb_get_property_sizeof (const void *_buffer /**< */) 3798 { 3799 char *xcb_tmp = (char *)_buffer; 3800 const xcb_get_property_reply_t *_aux = (xcb_get_property_reply_t *)_buffer; 3801 unsigned int xcb_buffer_len = 0; 3802 unsigned int xcb_block_len = 0; 3803 unsigned int xcb_pad = 0; 3804 unsigned int xcb_align_to; 3805 3806 3807 xcb_block_len += sizeof(xcb_get_property_reply_t); 3808 xcb_tmp += xcb_block_len; 3809 /* value */ 3810 xcb_block_len += (_aux->value_len * (_aux->format / 8)) * sizeof(char); 3811 xcb_tmp += xcb_block_len; 3812 xcb_align_to = ALIGNOF(char); 3813 /* insert padding */ 3814 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3815 xcb_buffer_len += xcb_block_len + xcb_pad; 3816 if (0 != xcb_pad) { 3817 xcb_tmp += xcb_pad; 3818 xcb_pad = 0; 3819 } 3820 xcb_block_len = 0; 3821 3822 return xcb_buffer_len; 3823 } 3824 3825 3826 /***************************************************************************** 3827 ** 3828 ** xcb_get_property_cookie_t xcb_get_property 3829 ** 3830 ** @param xcb_connection_t *c 3831 ** @param uint8_t _delete 3832 ** @param xcb_window_t window 3833 ** @param xcb_atom_t property 3834 ** @param xcb_atom_t type 3835 ** @param uint32_t long_offset 3836 ** @param uint32_t long_length 3837 ** @returns xcb_get_property_cookie_t 3838 ** 3839 *****************************************************************************/ 3840 3841 xcb_get_property_cookie_t 3842 xcb_get_property (xcb_connection_t *c /**< */, 3843 uint8_t _delete /**< */, 3844 xcb_window_t window /**< */, 3845 xcb_atom_t property /**< */, 3846 xcb_atom_t type /**< */, 3847 uint32_t long_offset /**< */, 3848 uint32_t long_length /**< */) 3849 { 3850 static const xcb_protocol_request_t xcb_req = { 3851 /* count */ 2, 3852 /* ext */ 0, 3853 /* opcode */ XCB_GET_PROPERTY, 3854 /* isvoid */ 0 3855 }; 3856 3857 struct iovec xcb_parts[4]; 3858 xcb_get_property_cookie_t xcb_ret; 3859 xcb_get_property_request_t xcb_out; 3860 3861 xcb_out._delete = _delete; 3862 xcb_out.window = window; 3863 xcb_out.property = property; 3864 xcb_out.type = type; 3865 xcb_out.long_offset = long_offset; 3866 xcb_out.long_length = long_length; 3867 3868 xcb_parts[2].iov_base = (char *) &xcb_out; 3869 xcb_parts[2].iov_len = sizeof(xcb_out); 3870 xcb_parts[3].iov_base = 0; 3871 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3872 3873 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3874 return xcb_ret; 3875 } 3876 3877 3878 /***************************************************************************** 3879 ** 3880 ** xcb_get_property_cookie_t xcb_get_property_unchecked 3881 ** 3882 ** @param xcb_connection_t *c 3883 ** @param uint8_t _delete 3884 ** @param xcb_window_t window 3885 ** @param xcb_atom_t property 3886 ** @param xcb_atom_t type 3887 ** @param uint32_t long_offset 3888 ** @param uint32_t long_length 3889 ** @returns xcb_get_property_cookie_t 3890 ** 3891 *****************************************************************************/ 3892 3893 xcb_get_property_cookie_t 3894 xcb_get_property_unchecked (xcb_connection_t *c /**< */, 3895 uint8_t _delete /**< */, 3896 xcb_window_t window /**< */, 3897 xcb_atom_t property /**< */, 3898 xcb_atom_t type /**< */, 3899 uint32_t long_offset /**< */, 3900 uint32_t long_length /**< */) 3901 { 3902 static const xcb_protocol_request_t xcb_req = { 3903 /* count */ 2, 3904 /* ext */ 0, 3905 /* opcode */ XCB_GET_PROPERTY, 3906 /* isvoid */ 0 3907 }; 3908 3909 struct iovec xcb_parts[4]; 3910 xcb_get_property_cookie_t xcb_ret; 3911 xcb_get_property_request_t xcb_out; 3912 3913 xcb_out._delete = _delete; 3914 xcb_out.window = window; 3915 xcb_out.property = property; 3916 xcb_out.type = type; 3917 xcb_out.long_offset = long_offset; 3918 xcb_out.long_length = long_length; 3919 3920 xcb_parts[2].iov_base = (char *) &xcb_out; 3921 xcb_parts[2].iov_len = sizeof(xcb_out); 3922 xcb_parts[3].iov_base = 0; 3923 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3924 3925 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3926 return xcb_ret; 3927 } 3928 3929 3930 /***************************************************************************** 3931 ** 3932 ** void * xcb_get_property_value 3933 ** 3934 ** @param const xcb_get_property_reply_t *R 3935 ** @returns void * 3936 ** 3937 *****************************************************************************/ 3938 3939 void * 3940 xcb_get_property_value (const xcb_get_property_reply_t *R /**< */) 3941 { 3942 return (void *) (R + 1); 3943 } 3944 3945 3946 /***************************************************************************** 3947 ** 3948 ** int xcb_get_property_value_length 3949 ** 3950 ** @param const xcb_get_property_reply_t *R 3951 ** @returns int 3952 ** 3953 *****************************************************************************/ 3954 3955 int 3956 xcb_get_property_value_length (const xcb_get_property_reply_t *R /**< */) 3957 { 3958 return (R->value_len * (R->format / 8)); 3959 } 3960 3961 3962 /***************************************************************************** 3963 ** 3964 ** xcb_generic_iterator_t xcb_get_property_value_end 3965 ** 3966 ** @param const xcb_get_property_reply_t *R 3967 ** @returns xcb_generic_iterator_t 3968 ** 3969 *****************************************************************************/ 3970 3971 xcb_generic_iterator_t 3972 xcb_get_property_value_end (const xcb_get_property_reply_t *R /**< */) 3973 { 3974 xcb_generic_iterator_t i; 3975 i.data = ((char *) (R + 1)) + ((R->value_len * (R->format / 8))); 3976 i.rem = 0; 3977 i.index = (char *) i.data - (char *) R; 3978 return i; 3979 } 3980 3981 3982 /***************************************************************************** 3983 ** 3984 ** xcb_get_property_reply_t * xcb_get_property_reply 3985 ** 3986 ** @param xcb_connection_t *c 3987 ** @param xcb_get_property_cookie_t cookie 3988 ** @param xcb_generic_error_t **e 3989 ** @returns xcb_get_property_reply_t * 3990 ** 3991 *****************************************************************************/ 3992 3993 xcb_get_property_reply_t * 3994 xcb_get_property_reply (xcb_connection_t *c /**< */, 3995 xcb_get_property_cookie_t cookie /**< */, 3996 xcb_generic_error_t **e /**< */) 3997 { 3998 return (xcb_get_property_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3999 } 4000 4001 int 4002 xcb_list_properties_sizeof (const void *_buffer /**< */) 4003 { 4004 char *xcb_tmp = (char *)_buffer; 4005 const xcb_list_properties_reply_t *_aux = (xcb_list_properties_reply_t *)_buffer; 4006 unsigned int xcb_buffer_len = 0; 4007 unsigned int xcb_block_len = 0; 4008 unsigned int xcb_pad = 0; 4009 unsigned int xcb_align_to; 4010 4011 4012 xcb_block_len += sizeof(xcb_list_properties_reply_t); 4013 xcb_tmp += xcb_block_len; 4014 /* atoms */ 4015 xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t); 4016 xcb_tmp += xcb_block_len; 4017 xcb_align_to = ALIGNOF(xcb_atom_t); 4018 /* insert padding */ 4019 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 4020 xcb_buffer_len += xcb_block_len + xcb_pad; 4021 if (0 != xcb_pad) { 4022 xcb_tmp += xcb_pad; 4023 xcb_pad = 0; 4024 } 4025 xcb_block_len = 0; 4026 4027 return xcb_buffer_len; 4028 } 4029 4030 4031 /***************************************************************************** 4032 ** 4033 ** xcb_list_properties_cookie_t xcb_list_properties 4034 ** 4035 ** @param xcb_connection_t *c 4036 ** @param xcb_window_t window 4037 ** @returns xcb_list_properties_cookie_t 4038 ** 4039 *****************************************************************************/ 4040 4041 xcb_list_properties_cookie_t 4042 xcb_list_properties (xcb_connection_t *c /**< */, 4043 xcb_window_t window /**< */) 4044 { 4045 static const xcb_protocol_request_t xcb_req = { 4046 /* count */ 2, 4047 /* ext */ 0, 4048 /* opcode */ XCB_LIST_PROPERTIES, 4049 /* isvoid */ 0 4050 }; 4051 4052 struct iovec xcb_parts[4]; 4053 xcb_list_properties_cookie_t xcb_ret; 4054 xcb_list_properties_request_t xcb_out; 4055 4056 xcb_out.pad0 = 0; 4057 xcb_out.window = window; 4058 4059 xcb_parts[2].iov_base = (char *) &xcb_out; 4060 xcb_parts[2].iov_len = sizeof(xcb_out); 4061 xcb_parts[3].iov_base = 0; 4062 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4063 4064 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4065 return xcb_ret; 4066 } 4067 4068 4069 /***************************************************************************** 4070 ** 4071 ** xcb_list_properties_cookie_t xcb_list_properties_unchecked 4072 ** 4073 ** @param xcb_connection_t *c 4074 ** @param xcb_window_t window 4075 ** @returns xcb_list_properties_cookie_t 4076 ** 4077 *****************************************************************************/ 4078 4079 xcb_list_properties_cookie_t 4080 xcb_list_properties_unchecked (xcb_connection_t *c /**< */, 4081 xcb_window_t window /**< */) 4082 { 4083 static const xcb_protocol_request_t xcb_req = { 4084 /* count */ 2, 4085 /* ext */ 0, 4086 /* opcode */ XCB_LIST_PROPERTIES, 4087 /* isvoid */ 0 4088 }; 4089 4090 struct iovec xcb_parts[4]; 4091 xcb_list_properties_cookie_t xcb_ret; 4092 xcb_list_properties_request_t xcb_out; 4093 4094 xcb_out.pad0 = 0; 4095 xcb_out.window = window; 4096 4097 xcb_parts[2].iov_base = (char *) &xcb_out; 4098 xcb_parts[2].iov_len = sizeof(xcb_out); 4099 xcb_parts[3].iov_base = 0; 4100 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4101 4102 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4103 return xcb_ret; 4104 } 4105 4106 4107 /***************************************************************************** 4108 ** 4109 ** xcb_atom_t * xcb_list_properties_atoms 4110 ** 4111 ** @param const xcb_list_properties_reply_t *R 4112 ** @returns xcb_atom_t * 4113 ** 4114 *****************************************************************************/ 4115 4116 xcb_atom_t * 4117 xcb_list_properties_atoms (const xcb_list_properties_reply_t *R /**< */) 4118 { 4119 return (xcb_atom_t *) (R + 1); 4120 } 4121 4122 4123 /***************************************************************************** 4124 ** 4125 ** int xcb_list_properties_atoms_length 4126 ** 4127 ** @param const xcb_list_properties_reply_t *R 4128 ** @returns int 4129 ** 4130 *****************************************************************************/ 4131 4132 int 4133 xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R /**< */) 4134 { 4135 return R->atoms_len; 4136 } 4137 4138 4139 /***************************************************************************** 4140 ** 4141 ** xcb_generic_iterator_t xcb_list_properties_atoms_end 4142 ** 4143 ** @param const xcb_list_properties_reply_t *R 4144 ** @returns xcb_generic_iterator_t 4145 ** 4146 *****************************************************************************/ 4147 4148 xcb_generic_iterator_t 4149 xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R /**< */) 4150 { 4151 xcb_generic_iterator_t i; 4152 i.data = ((xcb_atom_t *) (R + 1)) + (R->atoms_len); 4153 i.rem = 0; 4154 i.index = (char *) i.data - (char *) R; 4155 return i; 4156 } 4157 4158 4159 /***************************************************************************** 4160 ** 4161 ** xcb_list_properties_reply_t * xcb_list_properties_reply 4162 ** 4163 ** @param xcb_connection_t *c 4164 ** @param xcb_list_properties_cookie_t cookie 4165 ** @param xcb_generic_error_t **e 4166 ** @returns xcb_list_properties_reply_t * 4167 ** 4168 *****************************************************************************/ 4169 4170 xcb_list_properties_reply_t * 4171 xcb_list_properties_reply (xcb_connection_t *c /**< */, 4172 xcb_list_properties_cookie_t cookie /**< */, 4173 xcb_generic_error_t **e /**< */) 4174 { 4175 return (xcb_list_properties_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4176 } 4177 4178 4179 /***************************************************************************** 4180 ** 4181 ** xcb_void_cookie_t xcb_set_selection_owner_checked 4182 ** 4183 ** @param xcb_connection_t *c 4184 ** @param xcb_window_t owner 4185 ** @param xcb_atom_t selection 4186 ** @param xcb_timestamp_t time 4187 ** @returns xcb_void_cookie_t 4188 ** 4189 *****************************************************************************/ 4190 4191 xcb_void_cookie_t 4192 xcb_set_selection_owner_checked (xcb_connection_t *c /**< */, 4193 xcb_window_t owner /**< */, 4194 xcb_atom_t selection /**< */, 4195 xcb_timestamp_t time /**< */) 4196 { 4197 static const xcb_protocol_request_t xcb_req = { 4198 /* count */ 2, 4199 /* ext */ 0, 4200 /* opcode */ XCB_SET_SELECTION_OWNER, 4201 /* isvoid */ 1 4202 }; 4203 4204 struct iovec xcb_parts[4]; 4205 xcb_void_cookie_t xcb_ret; 4206 xcb_set_selection_owner_request_t xcb_out; 4207 4208 xcb_out.pad0 = 0; 4209 xcb_out.owner = owner; 4210 xcb_out.selection = selection; 4211 xcb_out.time = time; 4212 4213 xcb_parts[2].iov_base = (char *) &xcb_out; 4214 xcb_parts[2].iov_len = sizeof(xcb_out); 4215 xcb_parts[3].iov_base = 0; 4216 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4217 4218 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4219 return xcb_ret; 4220 } 4221 4222 4223 /***************************************************************************** 4224 ** 4225 ** xcb_void_cookie_t xcb_set_selection_owner 4226 ** 4227 ** @param xcb_connection_t *c 4228 ** @param xcb_window_t owner 4229 ** @param xcb_atom_t selection 4230 ** @param xcb_timestamp_t time 4231 ** @returns xcb_void_cookie_t 4232 ** 4233 *****************************************************************************/ 4234 4235 xcb_void_cookie_t 4236 xcb_set_selection_owner (xcb_connection_t *c /**< */, 4237 xcb_window_t owner /**< */, 4238 xcb_atom_t selection /**< */, 4239 xcb_timestamp_t time /**< */) 4240 { 4241 static const xcb_protocol_request_t xcb_req = { 4242 /* count */ 2, 4243 /* ext */ 0, 4244 /* opcode */ XCB_SET_SELECTION_OWNER, 4245 /* isvoid */ 1 4246 }; 4247 4248 struct iovec xcb_parts[4]; 4249 xcb_void_cookie_t xcb_ret; 4250 xcb_set_selection_owner_request_t xcb_out; 4251 4252 xcb_out.pad0 = 0; 4253 xcb_out.owner = owner; 4254 xcb_out.selection = selection; 4255 xcb_out.time = time; 4256 4257 xcb_parts[2].iov_base = (char *) &xcb_out; 4258 xcb_parts[2].iov_len = sizeof(xcb_out); 4259 xcb_parts[3].iov_base = 0; 4260 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4261 4262 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4263 return xcb_ret; 4264 } 4265 4266 4267 /***************************************************************************** 4268 ** 4269 ** xcb_get_selection_owner_cookie_t xcb_get_selection_owner 4270 ** 4271 ** @param xcb_connection_t *c 4272 ** @param xcb_atom_t selection 4273 ** @returns xcb_get_selection_owner_cookie_t 4274 ** 4275 *****************************************************************************/ 4276 4277 xcb_get_selection_owner_cookie_t 4278 xcb_get_selection_owner (xcb_connection_t *c /**< */, 4279 xcb_atom_t selection /**< */) 4280 { 4281 static const xcb_protocol_request_t xcb_req = { 4282 /* count */ 2, 4283 /* ext */ 0, 4284 /* opcode */ XCB_GET_SELECTION_OWNER, 4285 /* isvoid */ 0 4286 }; 4287 4288 struct iovec xcb_parts[4]; 4289 xcb_get_selection_owner_cookie_t xcb_ret; 4290 xcb_get_selection_owner_request_t xcb_out; 4291 4292 xcb_out.pad0 = 0; 4293 xcb_out.selection = selection; 4294 4295 xcb_parts[2].iov_base = (char *) &xcb_out; 4296 xcb_parts[2].iov_len = sizeof(xcb_out); 4297 xcb_parts[3].iov_base = 0; 4298 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4299 4300 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4301 return xcb_ret; 4302 } 4303 4304 4305 /***************************************************************************** 4306 ** 4307 ** xcb_get_selection_owner_cookie_t xcb_get_selection_owner_unchecked 4308 ** 4309 ** @param xcb_connection_t *c 4310 ** @param xcb_atom_t selection 4311 ** @returns xcb_get_selection_owner_cookie_t 4312 ** 4313 *****************************************************************************/ 4314 4315 xcb_get_selection_owner_cookie_t 4316 xcb_get_selection_owner_unchecked (xcb_connection_t *c /**< */, 4317 xcb_atom_t selection /**< */) 4318 { 4319 static const xcb_protocol_request_t xcb_req = { 4320 /* count */ 2, 4321 /* ext */ 0, 4322 /* opcode */ XCB_GET_SELECTION_OWNER, 4323 /* isvoid */ 0 4324 }; 4325 4326 struct iovec xcb_parts[4]; 4327 xcb_get_selection_owner_cookie_t xcb_ret; 4328 xcb_get_selection_owner_request_t xcb_out; 4329 4330 xcb_out.pad0 = 0; 4331 xcb_out.selection = selection; 4332 4333 xcb_parts[2].iov_base = (char *) &xcb_out; 4334 xcb_parts[2].iov_len = sizeof(xcb_out); 4335 xcb_parts[3].iov_base = 0; 4336 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4337 4338 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4339 return xcb_ret; 4340 } 4341 4342 4343 /***************************************************************************** 4344 ** 4345 ** xcb_get_selection_owner_reply_t * xcb_get_selection_owner_reply 4346 ** 4347 ** @param xcb_connection_t *c 4348 ** @param xcb_get_selection_owner_cookie_t cookie 4349 ** @param xcb_generic_error_t **e 4350 ** @returns xcb_get_selection_owner_reply_t * 4351 ** 4352 *****************************************************************************/ 4353 4354 xcb_get_selection_owner_reply_t * 4355 xcb_get_selection_owner_reply (xcb_connection_t *c /**< */, 4356 xcb_get_selection_owner_cookie_t cookie /**< */, 4357 xcb_generic_error_t **e /**< */) 4358 { 4359 return (xcb_get_selection_owner_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4360 } 4361 4362 4363 /***************************************************************************** 4364 ** 4365 ** xcb_void_cookie_t xcb_convert_selection_checked 4366 ** 4367 ** @param xcb_connection_t *c 4368 ** @param xcb_window_t requestor 4369 ** @param xcb_atom_t selection 4370 ** @param xcb_atom_t target 4371 ** @param xcb_atom_t property 4372 ** @param xcb_timestamp_t time 4373 ** @returns xcb_void_cookie_t 4374 ** 4375 *****************************************************************************/ 4376 4377 xcb_void_cookie_t 4378 xcb_convert_selection_checked (xcb_connection_t *c /**< */, 4379 xcb_window_t requestor /**< */, 4380 xcb_atom_t selection /**< */, 4381 xcb_atom_t target /**< */, 4382 xcb_atom_t property /**< */, 4383 xcb_timestamp_t time /**< */) 4384 { 4385 static const xcb_protocol_request_t xcb_req = { 4386 /* count */ 2, 4387 /* ext */ 0, 4388 /* opcode */ XCB_CONVERT_SELECTION, 4389 /* isvoid */ 1 4390 }; 4391 4392 struct iovec xcb_parts[4]; 4393 xcb_void_cookie_t xcb_ret; 4394 xcb_convert_selection_request_t xcb_out; 4395 4396 xcb_out.pad0 = 0; 4397 xcb_out.requestor = requestor; 4398 xcb_out.selection = selection; 4399 xcb_out.target = target; 4400 xcb_out.property = property; 4401 xcb_out.time = time; 4402 4403 xcb_parts[2].iov_base = (char *) &xcb_out; 4404 xcb_parts[2].iov_len = sizeof(xcb_out); 4405 xcb_parts[3].iov_base = 0; 4406 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4407 4408 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4409 return xcb_ret; 4410 } 4411 4412 4413 /***************************************************************************** 4414 ** 4415 ** xcb_void_cookie_t xcb_convert_selection 4416 ** 4417 ** @param xcb_connection_t *c 4418 ** @param xcb_window_t requestor 4419 ** @param xcb_atom_t selection 4420 ** @param xcb_atom_t target 4421 ** @param xcb_atom_t property 4422 ** @param xcb_timestamp_t time 4423 ** @returns xcb_void_cookie_t 4424 ** 4425 *****************************************************************************/ 4426 4427 xcb_void_cookie_t 4428 xcb_convert_selection (xcb_connection_t *c /**< */, 4429 xcb_window_t requestor /**< */, 4430 xcb_atom_t selection /**< */, 4431 xcb_atom_t target /**< */, 4432 xcb_atom_t property /**< */, 4433 xcb_timestamp_t time /**< */) 4434 { 4435 static const xcb_protocol_request_t xcb_req = { 4436 /* count */ 2, 4437 /* ext */ 0, 4438 /* opcode */ XCB_CONVERT_SELECTION, 4439 /* isvoid */ 1 4440 }; 4441 4442 struct iovec xcb_parts[4]; 4443 xcb_void_cookie_t xcb_ret; 4444 xcb_convert_selection_request_t xcb_out; 4445 4446 xcb_out.pad0 = 0; 4447 xcb_out.requestor = requestor; 4448 xcb_out.selection = selection; 4449 xcb_out.target = target; 4450 xcb_out.property = property; 4451 xcb_out.time = time; 4452 4453 xcb_parts[2].iov_base = (char *) &xcb_out; 4454 xcb_parts[2].iov_len = sizeof(xcb_out); 4455 xcb_parts[3].iov_base = 0; 4456 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4457 4458 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4459 return xcb_ret; 4460 } 4461 4462 4463 /***************************************************************************** 4464 ** 4465 ** xcb_void_cookie_t xcb_send_event_checked 4466 ** 4467 ** @param xcb_connection_t *c 4468 ** @param uint8_t propagate 4469 ** @param xcb_window_t destination 4470 ** @param uint32_t event_mask 4471 ** @param const char *event 4472 ** @returns xcb_void_cookie_t 4473 ** 4474 *****************************************************************************/ 4475 4476 xcb_void_cookie_t 4477 xcb_send_event_checked (xcb_connection_t *c /**< */, 4478 uint8_t propagate /**< */, 4479 xcb_window_t destination /**< */, 4480 uint32_t event_mask /**< */, 4481 const char *event /**< */) 4482 { 4483 static const xcb_protocol_request_t xcb_req = { 4484 /* count */ 2, 4485 /* ext */ 0, 4486 /* opcode */ XCB_SEND_EVENT, 4487 /* isvoid */ 1 4488 }; 4489 4490 struct iovec xcb_parts[4]; 4491 xcb_void_cookie_t xcb_ret; 4492 xcb_send_event_request_t xcb_out; 4493 4494 xcb_out.propagate = propagate; 4495 xcb_out.destination = destination; 4496 xcb_out.event_mask = event_mask; 4497 memcpy(xcb_out.event, event, 32); 4498 4499 xcb_parts[2].iov_base = (char *) &xcb_out; 4500 xcb_parts[2].iov_len = sizeof(xcb_out); 4501 xcb_parts[3].iov_base = 0; 4502 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4503 4504 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4505 return xcb_ret; 4506 } 4507 4508 4509 /***************************************************************************** 4510 ** 4511 ** xcb_void_cookie_t xcb_send_event 4512 ** 4513 ** @param xcb_connection_t *c 4514 ** @param uint8_t propagate 4515 ** @param xcb_window_t destination 4516 ** @param uint32_t event_mask 4517 ** @param const char *event 4518 ** @returns xcb_void_cookie_t 4519 ** 4520 *****************************************************************************/ 4521 4522 xcb_void_cookie_t 4523 xcb_send_event (xcb_connection_t *c /**< */, 4524 uint8_t propagate /**< */, 4525 xcb_window_t destination /**< */, 4526 uint32_t event_mask /**< */, 4527 const char *event /**< */) 4528 { 4529 static const xcb_protocol_request_t xcb_req = { 4530 /* count */ 2, 4531 /* ext */ 0, 4532 /* opcode */ XCB_SEND_EVENT, 4533 /* isvoid */ 1 4534 }; 4535 4536 struct iovec xcb_parts[4]; 4537 xcb_void_cookie_t xcb_ret; 4538 xcb_send_event_request_t xcb_out; 4539 4540 xcb_out.propagate = propagate; 4541 xcb_out.destination = destination; 4542 xcb_out.event_mask = event_mask; 4543 memcpy(xcb_out.event, event, 32); 4544 4545 xcb_parts[2].iov_base = (char *) &xcb_out; 4546 xcb_parts[2].iov_len = sizeof(xcb_out); 4547 xcb_parts[3].iov_base = 0; 4548 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4549 4550 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4551 return xcb_ret; 4552 } 4553 4554 4555 /***************************************************************************** 4556 ** 4557 ** xcb_grab_pointer_cookie_t xcb_grab_pointer 4558 ** 4559 ** @param xcb_connection_t *c 4560 ** @param uint8_t owner_events 4561 ** @param xcb_window_t grab_window 4562 ** @param uint16_t event_mask 4563 ** @param uint8_t pointer_mode 4564 ** @param uint8_t keyboard_mode 4565 ** @param xcb_window_t confine_to 4566 ** @param xcb_cursor_t cursor 4567 ** @param xcb_timestamp_t time 4568 ** @returns xcb_grab_pointer_cookie_t 4569 ** 4570 *****************************************************************************/ 4571 4572 xcb_grab_pointer_cookie_t 4573 xcb_grab_pointer (xcb_connection_t *c /**< */, 4574 uint8_t owner_events /**< */, 4575 xcb_window_t grab_window /**< */, 4576 uint16_t event_mask /**< */, 4577 uint8_t pointer_mode /**< */, 4578 uint8_t keyboard_mode /**< */, 4579 xcb_window_t confine_to /**< */, 4580 xcb_cursor_t cursor /**< */, 4581 xcb_timestamp_t time /**< */) 4582 { 4583 static const xcb_protocol_request_t xcb_req = { 4584 /* count */ 2, 4585 /* ext */ 0, 4586 /* opcode */ XCB_GRAB_POINTER, 4587 /* isvoid */ 0 4588 }; 4589 4590 struct iovec xcb_parts[4]; 4591 xcb_grab_pointer_cookie_t xcb_ret; 4592 xcb_grab_pointer_request_t xcb_out; 4593 4594 xcb_out.owner_events = owner_events; 4595 xcb_out.grab_window = grab_window; 4596 xcb_out.event_mask = event_mask; 4597 xcb_out.pointer_mode = pointer_mode; 4598 xcb_out.keyboard_mode = keyboard_mode; 4599 xcb_out.confine_to = confine_to; 4600 xcb_out.cursor = cursor; 4601 xcb_out.time = time; 4602 4603 xcb_parts[2].iov_base = (char *) &xcb_out; 4604 xcb_parts[2].iov_len = sizeof(xcb_out); 4605 xcb_parts[3].iov_base = 0; 4606 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4607 4608 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4609 return xcb_ret; 4610 } 4611 4612 4613 /***************************************************************************** 4614 ** 4615 ** xcb_grab_pointer_cookie_t xcb_grab_pointer_unchecked 4616 ** 4617 ** @param xcb_connection_t *c 4618 ** @param uint8_t owner_events 4619 ** @param xcb_window_t grab_window 4620 ** @param uint16_t event_mask 4621 ** @param uint8_t pointer_mode 4622 ** @param uint8_t keyboard_mode 4623 ** @param xcb_window_t confine_to 4624 ** @param xcb_cursor_t cursor 4625 ** @param xcb_timestamp_t time 4626 ** @returns xcb_grab_pointer_cookie_t 4627 ** 4628 *****************************************************************************/ 4629 4630 xcb_grab_pointer_cookie_t 4631 xcb_grab_pointer_unchecked (xcb_connection_t *c /**< */, 4632 uint8_t owner_events /**< */, 4633 xcb_window_t grab_window /**< */, 4634 uint16_t event_mask /**< */, 4635 uint8_t pointer_mode /**< */, 4636 uint8_t keyboard_mode /**< */, 4637 xcb_window_t confine_to /**< */, 4638 xcb_cursor_t cursor /**< */, 4639 xcb_timestamp_t time /**< */) 4640 { 4641 static const xcb_protocol_request_t xcb_req = { 4642 /* count */ 2, 4643 /* ext */ 0, 4644 /* opcode */ XCB_GRAB_POINTER, 4645 /* isvoid */ 0 4646 }; 4647 4648 struct iovec xcb_parts[4]; 4649 xcb_grab_pointer_cookie_t xcb_ret; 4650 xcb_grab_pointer_request_t xcb_out; 4651 4652 xcb_out.owner_events = owner_events; 4653 xcb_out.grab_window = grab_window; 4654 xcb_out.event_mask = event_mask; 4655 xcb_out.pointer_mode = pointer_mode; 4656 xcb_out.keyboard_mode = keyboard_mode; 4657 xcb_out.confine_to = confine_to; 4658 xcb_out.cursor = cursor; 4659 xcb_out.time = time; 4660 4661 xcb_parts[2].iov_base = (char *) &xcb_out; 4662 xcb_parts[2].iov_len = sizeof(xcb_out); 4663 xcb_parts[3].iov_base = 0; 4664 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4665 4666 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4667 return xcb_ret; 4668 } 4669 4670 4671 /***************************************************************************** 4672 ** 4673 ** xcb_grab_pointer_reply_t * xcb_grab_pointer_reply 4674 ** 4675 ** @param xcb_connection_t *c 4676 ** @param xcb_grab_pointer_cookie_t cookie 4677 ** @param xcb_generic_error_t **e 4678 ** @returns xcb_grab_pointer_reply_t * 4679 ** 4680 *****************************************************************************/ 4681 4682 xcb_grab_pointer_reply_t * 4683 xcb_grab_pointer_reply (xcb_connection_t *c /**< */, 4684 xcb_grab_pointer_cookie_t cookie /**< */, 4685 xcb_generic_error_t **e /**< */) 4686 { 4687 return (xcb_grab_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 4688 } 4689 4690 4691 /***************************************************************************** 4692 ** 4693 ** xcb_void_cookie_t xcb_ungrab_pointer_checked 4694 ** 4695 ** @param xcb_connection_t *c 4696 ** @param xcb_timestamp_t time 4697 ** @returns xcb_void_cookie_t 4698 ** 4699 *****************************************************************************/ 4700 4701 xcb_void_cookie_t 4702 xcb_ungrab_pointer_checked (xcb_connection_t *c /**< */, 4703 xcb_timestamp_t time /**< */) 4704 { 4705 static const xcb_protocol_request_t xcb_req = { 4706 /* count */ 2, 4707 /* ext */ 0, 4708 /* opcode */ XCB_UNGRAB_POINTER, 4709 /* isvoid */ 1 4710 }; 4711 4712 struct iovec xcb_parts[4]; 4713 xcb_void_cookie_t xcb_ret; 4714 xcb_ungrab_pointer_request_t xcb_out; 4715 4716 xcb_out.pad0 = 0; 4717 xcb_out.time = time; 4718 4719 xcb_parts[2].iov_base = (char *) &xcb_out; 4720 xcb_parts[2].iov_len = sizeof(xcb_out); 4721 xcb_parts[3].iov_base = 0; 4722 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4723 4724 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4725 return xcb_ret; 4726 } 4727 4728 4729 /***************************************************************************** 4730 ** 4731 ** xcb_void_cookie_t xcb_ungrab_pointer 4732 ** 4733 ** @param xcb_connection_t *c 4734 ** @param xcb_timestamp_t time 4735 ** @returns xcb_void_cookie_t 4736 ** 4737 *****************************************************************************/ 4738 4739 xcb_void_cookie_t 4740 xcb_ungrab_pointer (xcb_connection_t *c /**< */, 4741 xcb_timestamp_t time /**< */) 4742 { 4743 static const xcb_protocol_request_t xcb_req = { 4744 /* count */ 2, 4745 /* ext */ 0, 4746 /* opcode */ XCB_UNGRAB_POINTER, 4747 /* isvoid */ 1 4748 }; 4749 4750 struct iovec xcb_parts[4]; 4751 xcb_void_cookie_t xcb_ret; 4752 xcb_ungrab_pointer_request_t xcb_out; 4753 4754 xcb_out.pad0 = 0; 4755 xcb_out.time = time; 4756 4757 xcb_parts[2].iov_base = (char *) &xcb_out; 4758 xcb_parts[2].iov_len = sizeof(xcb_out); 4759 xcb_parts[3].iov_base = 0; 4760 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4761 4762 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4763 return xcb_ret; 4764 } 4765 4766 4767 /***************************************************************************** 4768 ** 4769 ** xcb_void_cookie_t xcb_grab_button_checked 4770 ** 4771 ** @param xcb_connection_t *c 4772 ** @param uint8_t owner_events 4773 ** @param xcb_window_t grab_window 4774 ** @param uint16_t event_mask 4775 ** @param uint8_t pointer_mode 4776 ** @param uint8_t keyboard_mode 4777 ** @param xcb_window_t confine_to 4778 ** @param xcb_cursor_t cursor 4779 ** @param uint8_t button 4780 ** @param uint16_t modifiers 4781 ** @returns xcb_void_cookie_t 4782 ** 4783 *****************************************************************************/ 4784 4785 xcb_void_cookie_t 4786 xcb_grab_button_checked (xcb_connection_t *c /**< */, 4787 uint8_t owner_events /**< */, 4788 xcb_window_t grab_window /**< */, 4789 uint16_t event_mask /**< */, 4790 uint8_t pointer_mode /**< */, 4791 uint8_t keyboard_mode /**< */, 4792 xcb_window_t confine_to /**< */, 4793 xcb_cursor_t cursor /**< */, 4794 uint8_t button /**< */, 4795 uint16_t modifiers /**< */) 4796 { 4797 static const xcb_protocol_request_t xcb_req = { 4798 /* count */ 2, 4799 /* ext */ 0, 4800 /* opcode */ XCB_GRAB_BUTTON, 4801 /* isvoid */ 1 4802 }; 4803 4804 struct iovec xcb_parts[4]; 4805 xcb_void_cookie_t xcb_ret; 4806 xcb_grab_button_request_t xcb_out; 4807 4808 xcb_out.owner_events = owner_events; 4809 xcb_out.grab_window = grab_window; 4810 xcb_out.event_mask = event_mask; 4811 xcb_out.pointer_mode = pointer_mode; 4812 xcb_out.keyboard_mode = keyboard_mode; 4813 xcb_out.confine_to = confine_to; 4814 xcb_out.cursor = cursor; 4815 xcb_out.button = button; 4816 xcb_out.pad0 = 0; 4817 xcb_out.modifiers = modifiers; 4818 4819 xcb_parts[2].iov_base = (char *) &xcb_out; 4820 xcb_parts[2].iov_len = sizeof(xcb_out); 4821 xcb_parts[3].iov_base = 0; 4822 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4823 4824 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4825 return xcb_ret; 4826 } 4827 4828 4829 /***************************************************************************** 4830 ** 4831 ** xcb_void_cookie_t xcb_grab_button 4832 ** 4833 ** @param xcb_connection_t *c 4834 ** @param uint8_t owner_events 4835 ** @param xcb_window_t grab_window 4836 ** @param uint16_t event_mask 4837 ** @param uint8_t pointer_mode 4838 ** @param uint8_t keyboard_mode 4839 ** @param xcb_window_t confine_to 4840 ** @param xcb_cursor_t cursor 4841 ** @param uint8_t button 4842 ** @param uint16_t modifiers 4843 ** @returns xcb_void_cookie_t 4844 ** 4845 *****************************************************************************/ 4846 4847 xcb_void_cookie_t 4848 xcb_grab_button (xcb_connection_t *c /**< */, 4849 uint8_t owner_events /**< */, 4850 xcb_window_t grab_window /**< */, 4851 uint16_t event_mask /**< */, 4852 uint8_t pointer_mode /**< */, 4853 uint8_t keyboard_mode /**< */, 4854 xcb_window_t confine_to /**< */, 4855 xcb_cursor_t cursor /**< */, 4856 uint8_t button /**< */, 4857 uint16_t modifiers /**< */) 4858 { 4859 static const xcb_protocol_request_t xcb_req = { 4860 /* count */ 2, 4861 /* ext */ 0, 4862 /* opcode */ XCB_GRAB_BUTTON, 4863 /* isvoid */ 1 4864 }; 4865 4866 struct iovec xcb_parts[4]; 4867 xcb_void_cookie_t xcb_ret; 4868 xcb_grab_button_request_t xcb_out; 4869 4870 xcb_out.owner_events = owner_events; 4871 xcb_out.grab_window = grab_window; 4872 xcb_out.event_mask = event_mask; 4873 xcb_out.pointer_mode = pointer_mode; 4874 xcb_out.keyboard_mode = keyboard_mode; 4875 xcb_out.confine_to = confine_to; 4876 xcb_out.cursor = cursor; 4877 xcb_out.button = button; 4878 xcb_out.pad0 = 0; 4879 xcb_out.modifiers = modifiers; 4880 4881 xcb_parts[2].iov_base = (char *) &xcb_out; 4882 xcb_parts[2].iov_len = sizeof(xcb_out); 4883 xcb_parts[3].iov_base = 0; 4884 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4885 4886 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4887 return xcb_ret; 4888 } 4889 4890 4891 /***************************************************************************** 4892 ** 4893 ** xcb_void_cookie_t xcb_ungrab_button_checked 4894 ** 4895 ** @param xcb_connection_t *c 4896 ** @param uint8_t button 4897 ** @param xcb_window_t grab_window 4898 ** @param uint16_t modifiers 4899 ** @returns xcb_void_cookie_t 4900 ** 4901 *****************************************************************************/ 4902 4903 xcb_void_cookie_t 4904 xcb_ungrab_button_checked (xcb_connection_t *c /**< */, 4905 uint8_t button /**< */, 4906 xcb_window_t grab_window /**< */, 4907 uint16_t modifiers /**< */) 4908 { 4909 static const xcb_protocol_request_t xcb_req = { 4910 /* count */ 2, 4911 /* ext */ 0, 4912 /* opcode */ XCB_UNGRAB_BUTTON, 4913 /* isvoid */ 1 4914 }; 4915 4916 struct iovec xcb_parts[4]; 4917 xcb_void_cookie_t xcb_ret; 4918 xcb_ungrab_button_request_t xcb_out; 4919 4920 xcb_out.button = button; 4921 xcb_out.grab_window = grab_window; 4922 xcb_out.modifiers = modifiers; 4923 memset(xcb_out.pad0, 0, 2); 4924 4925 xcb_parts[2].iov_base = (char *) &xcb_out; 4926 xcb_parts[2].iov_len = sizeof(xcb_out); 4927 xcb_parts[3].iov_base = 0; 4928 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4929 4930 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 4931 return xcb_ret; 4932 } 4933 4934 4935 /***************************************************************************** 4936 ** 4937 ** xcb_void_cookie_t xcb_ungrab_button 4938 ** 4939 ** @param xcb_connection_t *c 4940 ** @param uint8_t button 4941 ** @param xcb_window_t grab_window 4942 ** @param uint16_t modifiers 4943 ** @returns xcb_void_cookie_t 4944 ** 4945 *****************************************************************************/ 4946 4947 xcb_void_cookie_t 4948 xcb_ungrab_button (xcb_connection_t *c /**< */, 4949 uint8_t button /**< */, 4950 xcb_window_t grab_window /**< */, 4951 uint16_t modifiers /**< */) 4952 { 4953 static const xcb_protocol_request_t xcb_req = { 4954 /* count */ 2, 4955 /* ext */ 0, 4956 /* opcode */ XCB_UNGRAB_BUTTON, 4957 /* isvoid */ 1 4958 }; 4959 4960 struct iovec xcb_parts[4]; 4961 xcb_void_cookie_t xcb_ret; 4962 xcb_ungrab_button_request_t xcb_out; 4963 4964 xcb_out.button = button; 4965 xcb_out.grab_window = grab_window; 4966 xcb_out.modifiers = modifiers; 4967 memset(xcb_out.pad0, 0, 2); 4968 4969 xcb_parts[2].iov_base = (char *) &xcb_out; 4970 xcb_parts[2].iov_len = sizeof(xcb_out); 4971 xcb_parts[3].iov_base = 0; 4972 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 4973 4974 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 4975 return xcb_ret; 4976 } 4977 4978 4979 /***************************************************************************** 4980 ** 4981 ** xcb_void_cookie_t xcb_change_active_pointer_grab_checked 4982 ** 4983 ** @param xcb_connection_t *c 4984 ** @param xcb_cursor_t cursor 4985 ** @param xcb_timestamp_t time 4986 ** @param uint16_t event_mask 4987 ** @returns xcb_void_cookie_t 4988 ** 4989 *****************************************************************************/ 4990 4991 xcb_void_cookie_t 4992 xcb_change_active_pointer_grab_checked (xcb_connection_t *c /**< */, 4993 xcb_cursor_t cursor /**< */, 4994 xcb_timestamp_t time /**< */, 4995 uint16_t event_mask /**< */) 4996 { 4997 static const xcb_protocol_request_t xcb_req = { 4998 /* count */ 2, 4999 /* ext */ 0, 5000 /* opcode */ XCB_CHANGE_ACTIVE_POINTER_GRAB, 5001 /* isvoid */ 1 5002 }; 5003 5004 struct iovec xcb_parts[4]; 5005 xcb_void_cookie_t xcb_ret; 5006 xcb_change_active_pointer_grab_request_t xcb_out; 5007 5008 xcb_out.pad0 = 0; 5009 xcb_out.cursor = cursor; 5010 xcb_out.time = time; 5011 xcb_out.event_mask = event_mask; 5012 memset(xcb_out.pad1, 0, 2); 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 5019 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5020 return xcb_ret; 5021 } 5022 5023 5024 /***************************************************************************** 5025 ** 5026 ** xcb_void_cookie_t xcb_change_active_pointer_grab 5027 ** 5028 ** @param xcb_connection_t *c 5029 ** @param xcb_cursor_t cursor 5030 ** @param xcb_timestamp_t time 5031 ** @param uint16_t event_mask 5032 ** @returns xcb_void_cookie_t 5033 ** 5034 *****************************************************************************/ 5035 5036 xcb_void_cookie_t 5037 xcb_change_active_pointer_grab (xcb_connection_t *c /**< */, 5038 xcb_cursor_t cursor /**< */, 5039 xcb_timestamp_t time /**< */, 5040 uint16_t event_mask /**< */) 5041 { 5042 static const xcb_protocol_request_t xcb_req = { 5043 /* count */ 2, 5044 /* ext */ 0, 5045 /* opcode */ XCB_CHANGE_ACTIVE_POINTER_GRAB, 5046 /* isvoid */ 1 5047 }; 5048 5049 struct iovec xcb_parts[4]; 5050 xcb_void_cookie_t xcb_ret; 5051 xcb_change_active_pointer_grab_request_t xcb_out; 5052 5053 xcb_out.pad0 = 0; 5054 xcb_out.cursor = cursor; 5055 xcb_out.time = time; 5056 xcb_out.event_mask = event_mask; 5057 memset(xcb_out.pad1, 0, 2); 5058 5059 xcb_parts[2].iov_base = (char *) &xcb_out; 5060 xcb_parts[2].iov_len = sizeof(xcb_out); 5061 xcb_parts[3].iov_base = 0; 5062 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5063 5064 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5065 return xcb_ret; 5066 } 5067 5068 5069 /***************************************************************************** 5070 ** 5071 ** xcb_grab_keyboard_cookie_t xcb_grab_keyboard 5072 ** 5073 ** @param xcb_connection_t *c 5074 ** @param uint8_t owner_events 5075 ** @param xcb_window_t grab_window 5076 ** @param xcb_timestamp_t time 5077 ** @param uint8_t pointer_mode 5078 ** @param uint8_t keyboard_mode 5079 ** @returns xcb_grab_keyboard_cookie_t 5080 ** 5081 *****************************************************************************/ 5082 5083 xcb_grab_keyboard_cookie_t 5084 xcb_grab_keyboard (xcb_connection_t *c /**< */, 5085 uint8_t owner_events /**< */, 5086 xcb_window_t grab_window /**< */, 5087 xcb_timestamp_t time /**< */, 5088 uint8_t pointer_mode /**< */, 5089 uint8_t keyboard_mode /**< */) 5090 { 5091 static const xcb_protocol_request_t xcb_req = { 5092 /* count */ 2, 5093 /* ext */ 0, 5094 /* opcode */ XCB_GRAB_KEYBOARD, 5095 /* isvoid */ 0 5096 }; 5097 5098 struct iovec xcb_parts[4]; 5099 xcb_grab_keyboard_cookie_t xcb_ret; 5100 xcb_grab_keyboard_request_t xcb_out; 5101 5102 xcb_out.owner_events = owner_events; 5103 xcb_out.grab_window = grab_window; 5104 xcb_out.time = time; 5105 xcb_out.pointer_mode = pointer_mode; 5106 xcb_out.keyboard_mode = keyboard_mode; 5107 memset(xcb_out.pad0, 0, 2); 5108 5109 xcb_parts[2].iov_base = (char *) &xcb_out; 5110 xcb_parts[2].iov_len = sizeof(xcb_out); 5111 xcb_parts[3].iov_base = 0; 5112 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5113 5114 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5115 return xcb_ret; 5116 } 5117 5118 5119 /***************************************************************************** 5120 ** 5121 ** xcb_grab_keyboard_cookie_t xcb_grab_keyboard_unchecked 5122 ** 5123 ** @param xcb_connection_t *c 5124 ** @param uint8_t owner_events 5125 ** @param xcb_window_t grab_window 5126 ** @param xcb_timestamp_t time 5127 ** @param uint8_t pointer_mode 5128 ** @param uint8_t keyboard_mode 5129 ** @returns xcb_grab_keyboard_cookie_t 5130 ** 5131 *****************************************************************************/ 5132 5133 xcb_grab_keyboard_cookie_t 5134 xcb_grab_keyboard_unchecked (xcb_connection_t *c /**< */, 5135 uint8_t owner_events /**< */, 5136 xcb_window_t grab_window /**< */, 5137 xcb_timestamp_t time /**< */, 5138 uint8_t pointer_mode /**< */, 5139 uint8_t keyboard_mode /**< */) 5140 { 5141 static const xcb_protocol_request_t xcb_req = { 5142 /* count */ 2, 5143 /* ext */ 0, 5144 /* opcode */ XCB_GRAB_KEYBOARD, 5145 /* isvoid */ 0 5146 }; 5147 5148 struct iovec xcb_parts[4]; 5149 xcb_grab_keyboard_cookie_t xcb_ret; 5150 xcb_grab_keyboard_request_t xcb_out; 5151 5152 xcb_out.owner_events = owner_events; 5153 xcb_out.grab_window = grab_window; 5154 xcb_out.time = time; 5155 xcb_out.pointer_mode = pointer_mode; 5156 xcb_out.keyboard_mode = keyboard_mode; 5157 memset(xcb_out.pad0, 0, 2); 5158 5159 xcb_parts[2].iov_base = (char *) &xcb_out; 5160 xcb_parts[2].iov_len = sizeof(xcb_out); 5161 xcb_parts[3].iov_base = 0; 5162 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5163 5164 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5165 return xcb_ret; 5166 } 5167 5168 5169 /***************************************************************************** 5170 ** 5171 ** xcb_grab_keyboard_reply_t * xcb_grab_keyboard_reply 5172 ** 5173 ** @param xcb_connection_t *c 5174 ** @param xcb_grab_keyboard_cookie_t cookie 5175 ** @param xcb_generic_error_t **e 5176 ** @returns xcb_grab_keyboard_reply_t * 5177 ** 5178 *****************************************************************************/ 5179 5180 xcb_grab_keyboard_reply_t * 5181 xcb_grab_keyboard_reply (xcb_connection_t *c /**< */, 5182 xcb_grab_keyboard_cookie_t cookie /**< */, 5183 xcb_generic_error_t **e /**< */) 5184 { 5185 return (xcb_grab_keyboard_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5186 } 5187 5188 5189 /***************************************************************************** 5190 ** 5191 ** xcb_void_cookie_t xcb_ungrab_keyboard_checked 5192 ** 5193 ** @param xcb_connection_t *c 5194 ** @param xcb_timestamp_t time 5195 ** @returns xcb_void_cookie_t 5196 ** 5197 *****************************************************************************/ 5198 5199 xcb_void_cookie_t 5200 xcb_ungrab_keyboard_checked (xcb_connection_t *c /**< */, 5201 xcb_timestamp_t time /**< */) 5202 { 5203 static const xcb_protocol_request_t xcb_req = { 5204 /* count */ 2, 5205 /* ext */ 0, 5206 /* opcode */ XCB_UNGRAB_KEYBOARD, 5207 /* isvoid */ 1 5208 }; 5209 5210 struct iovec xcb_parts[4]; 5211 xcb_void_cookie_t xcb_ret; 5212 xcb_ungrab_keyboard_request_t xcb_out; 5213 5214 xcb_out.pad0 = 0; 5215 xcb_out.time = time; 5216 5217 xcb_parts[2].iov_base = (char *) &xcb_out; 5218 xcb_parts[2].iov_len = sizeof(xcb_out); 5219 xcb_parts[3].iov_base = 0; 5220 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5221 5222 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5223 return xcb_ret; 5224 } 5225 5226 5227 /***************************************************************************** 5228 ** 5229 ** xcb_void_cookie_t xcb_ungrab_keyboard 5230 ** 5231 ** @param xcb_connection_t *c 5232 ** @param xcb_timestamp_t time 5233 ** @returns xcb_void_cookie_t 5234 ** 5235 *****************************************************************************/ 5236 5237 xcb_void_cookie_t 5238 xcb_ungrab_keyboard (xcb_connection_t *c /**< */, 5239 xcb_timestamp_t time /**< */) 5240 { 5241 static const xcb_protocol_request_t xcb_req = { 5242 /* count */ 2, 5243 /* ext */ 0, 5244 /* opcode */ XCB_UNGRAB_KEYBOARD, 5245 /* isvoid */ 1 5246 }; 5247 5248 struct iovec xcb_parts[4]; 5249 xcb_void_cookie_t xcb_ret; 5250 xcb_ungrab_keyboard_request_t xcb_out; 5251 5252 xcb_out.pad0 = 0; 5253 xcb_out.time = time; 5254 5255 xcb_parts[2].iov_base = (char *) &xcb_out; 5256 xcb_parts[2].iov_len = sizeof(xcb_out); 5257 xcb_parts[3].iov_base = 0; 5258 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5259 5260 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5261 return xcb_ret; 5262 } 5263 5264 5265 /***************************************************************************** 5266 ** 5267 ** xcb_void_cookie_t xcb_grab_key_checked 5268 ** 5269 ** @param xcb_connection_t *c 5270 ** @param uint8_t owner_events 5271 ** @param xcb_window_t grab_window 5272 ** @param uint16_t modifiers 5273 ** @param xcb_keycode_t key 5274 ** @param uint8_t pointer_mode 5275 ** @param uint8_t keyboard_mode 5276 ** @returns xcb_void_cookie_t 5277 ** 5278 *****************************************************************************/ 5279 5280 xcb_void_cookie_t 5281 xcb_grab_key_checked (xcb_connection_t *c /**< */, 5282 uint8_t owner_events /**< */, 5283 xcb_window_t grab_window /**< */, 5284 uint16_t modifiers /**< */, 5285 xcb_keycode_t key /**< */, 5286 uint8_t pointer_mode /**< */, 5287 uint8_t keyboard_mode /**< */) 5288 { 5289 static const xcb_protocol_request_t xcb_req = { 5290 /* count */ 2, 5291 /* ext */ 0, 5292 /* opcode */ XCB_GRAB_KEY, 5293 /* isvoid */ 1 5294 }; 5295 5296 struct iovec xcb_parts[4]; 5297 xcb_void_cookie_t xcb_ret; 5298 xcb_grab_key_request_t xcb_out; 5299 5300 xcb_out.owner_events = owner_events; 5301 xcb_out.grab_window = grab_window; 5302 xcb_out.modifiers = modifiers; 5303 xcb_out.key = key; 5304 xcb_out.pointer_mode = pointer_mode; 5305 xcb_out.keyboard_mode = keyboard_mode; 5306 memset(xcb_out.pad0, 0, 3); 5307 5308 xcb_parts[2].iov_base = (char *) &xcb_out; 5309 xcb_parts[2].iov_len = sizeof(xcb_out); 5310 xcb_parts[3].iov_base = 0; 5311 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5312 5313 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5314 return xcb_ret; 5315 } 5316 5317 5318 /***************************************************************************** 5319 ** 5320 ** xcb_void_cookie_t xcb_grab_key 5321 ** 5322 ** @param xcb_connection_t *c 5323 ** @param uint8_t owner_events 5324 ** @param xcb_window_t grab_window 5325 ** @param uint16_t modifiers 5326 ** @param xcb_keycode_t key 5327 ** @param uint8_t pointer_mode 5328 ** @param uint8_t keyboard_mode 5329 ** @returns xcb_void_cookie_t 5330 ** 5331 *****************************************************************************/ 5332 5333 xcb_void_cookie_t 5334 xcb_grab_key (xcb_connection_t *c /**< */, 5335 uint8_t owner_events /**< */, 5336 xcb_window_t grab_window /**< */, 5337 uint16_t modifiers /**< */, 5338 xcb_keycode_t key /**< */, 5339 uint8_t pointer_mode /**< */, 5340 uint8_t keyboard_mode /**< */) 5341 { 5342 static const xcb_protocol_request_t xcb_req = { 5343 /* count */ 2, 5344 /* ext */ 0, 5345 /* opcode */ XCB_GRAB_KEY, 5346 /* isvoid */ 1 5347 }; 5348 5349 struct iovec xcb_parts[4]; 5350 xcb_void_cookie_t xcb_ret; 5351 xcb_grab_key_request_t xcb_out; 5352 5353 xcb_out.owner_events = owner_events; 5354 xcb_out.grab_window = grab_window; 5355 xcb_out.modifiers = modifiers; 5356 xcb_out.key = key; 5357 xcb_out.pointer_mode = pointer_mode; 5358 xcb_out.keyboard_mode = keyboard_mode; 5359 memset(xcb_out.pad0, 0, 3); 5360 5361 xcb_parts[2].iov_base = (char *) &xcb_out; 5362 xcb_parts[2].iov_len = sizeof(xcb_out); 5363 xcb_parts[3].iov_base = 0; 5364 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5365 5366 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5367 return xcb_ret; 5368 } 5369 5370 5371 /***************************************************************************** 5372 ** 5373 ** xcb_void_cookie_t xcb_ungrab_key_checked 5374 ** 5375 ** @param xcb_connection_t *c 5376 ** @param xcb_keycode_t key 5377 ** @param xcb_window_t grab_window 5378 ** @param uint16_t modifiers 5379 ** @returns xcb_void_cookie_t 5380 ** 5381 *****************************************************************************/ 5382 5383 xcb_void_cookie_t 5384 xcb_ungrab_key_checked (xcb_connection_t *c /**< */, 5385 xcb_keycode_t key /**< */, 5386 xcb_window_t grab_window /**< */, 5387 uint16_t modifiers /**< */) 5388 { 5389 static const xcb_protocol_request_t xcb_req = { 5390 /* count */ 2, 5391 /* ext */ 0, 5392 /* opcode */ XCB_UNGRAB_KEY, 5393 /* isvoid */ 1 5394 }; 5395 5396 struct iovec xcb_parts[4]; 5397 xcb_void_cookie_t xcb_ret; 5398 xcb_ungrab_key_request_t xcb_out; 5399 5400 xcb_out.key = key; 5401 xcb_out.grab_window = grab_window; 5402 xcb_out.modifiers = modifiers; 5403 memset(xcb_out.pad0, 0, 2); 5404 5405 xcb_parts[2].iov_base = (char *) &xcb_out; 5406 xcb_parts[2].iov_len = sizeof(xcb_out); 5407 xcb_parts[3].iov_base = 0; 5408 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5409 5410 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5411 return xcb_ret; 5412 } 5413 5414 5415 /***************************************************************************** 5416 ** 5417 ** xcb_void_cookie_t xcb_ungrab_key 5418 ** 5419 ** @param xcb_connection_t *c 5420 ** @param xcb_keycode_t key 5421 ** @param xcb_window_t grab_window 5422 ** @param uint16_t modifiers 5423 ** @returns xcb_void_cookie_t 5424 ** 5425 *****************************************************************************/ 5426 5427 xcb_void_cookie_t 5428 xcb_ungrab_key (xcb_connection_t *c /**< */, 5429 xcb_keycode_t key /**< */, 5430 xcb_window_t grab_window /**< */, 5431 uint16_t modifiers /**< */) 5432 { 5433 static const xcb_protocol_request_t xcb_req = { 5434 /* count */ 2, 5435 /* ext */ 0, 5436 /* opcode */ XCB_UNGRAB_KEY, 5437 /* isvoid */ 1 5438 }; 5439 5440 struct iovec xcb_parts[4]; 5441 xcb_void_cookie_t xcb_ret; 5442 xcb_ungrab_key_request_t xcb_out; 5443 5444 xcb_out.key = key; 5445 xcb_out.grab_window = grab_window; 5446 xcb_out.modifiers = modifiers; 5447 memset(xcb_out.pad0, 0, 2); 5448 5449 xcb_parts[2].iov_base = (char *) &xcb_out; 5450 xcb_parts[2].iov_len = sizeof(xcb_out); 5451 xcb_parts[3].iov_base = 0; 5452 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5453 5454 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5455 return xcb_ret; 5456 } 5457 5458 5459 /***************************************************************************** 5460 ** 5461 ** xcb_void_cookie_t xcb_allow_events_checked 5462 ** 5463 ** @param xcb_connection_t *c 5464 ** @param uint8_t mode 5465 ** @param xcb_timestamp_t time 5466 ** @returns xcb_void_cookie_t 5467 ** 5468 *****************************************************************************/ 5469 5470 xcb_void_cookie_t 5471 xcb_allow_events_checked (xcb_connection_t *c /**< */, 5472 uint8_t mode /**< */, 5473 xcb_timestamp_t time /**< */) 5474 { 5475 static const xcb_protocol_request_t xcb_req = { 5476 /* count */ 2, 5477 /* ext */ 0, 5478 /* opcode */ XCB_ALLOW_EVENTS, 5479 /* isvoid */ 1 5480 }; 5481 5482 struct iovec xcb_parts[4]; 5483 xcb_void_cookie_t xcb_ret; 5484 xcb_allow_events_request_t xcb_out; 5485 5486 xcb_out.mode = mode; 5487 xcb_out.time = time; 5488 5489 xcb_parts[2].iov_base = (char *) &xcb_out; 5490 xcb_parts[2].iov_len = sizeof(xcb_out); 5491 xcb_parts[3].iov_base = 0; 5492 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5493 5494 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5495 return xcb_ret; 5496 } 5497 5498 5499 /***************************************************************************** 5500 ** 5501 ** xcb_void_cookie_t xcb_allow_events 5502 ** 5503 ** @param xcb_connection_t *c 5504 ** @param uint8_t mode 5505 ** @param xcb_timestamp_t time 5506 ** @returns xcb_void_cookie_t 5507 ** 5508 *****************************************************************************/ 5509 5510 xcb_void_cookie_t 5511 xcb_allow_events (xcb_connection_t *c /**< */, 5512 uint8_t mode /**< */, 5513 xcb_timestamp_t time /**< */) 5514 { 5515 static const xcb_protocol_request_t xcb_req = { 5516 /* count */ 2, 5517 /* ext */ 0, 5518 /* opcode */ XCB_ALLOW_EVENTS, 5519 /* isvoid */ 1 5520 }; 5521 5522 struct iovec xcb_parts[4]; 5523 xcb_void_cookie_t xcb_ret; 5524 xcb_allow_events_request_t xcb_out; 5525 5526 xcb_out.mode = mode; 5527 xcb_out.time = time; 5528 5529 xcb_parts[2].iov_base = (char *) &xcb_out; 5530 xcb_parts[2].iov_len = sizeof(xcb_out); 5531 xcb_parts[3].iov_base = 0; 5532 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5533 5534 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5535 return xcb_ret; 5536 } 5537 5538 5539 /***************************************************************************** 5540 ** 5541 ** xcb_void_cookie_t xcb_grab_server_checked 5542 ** 5543 ** @param xcb_connection_t *c 5544 ** @returns xcb_void_cookie_t 5545 ** 5546 *****************************************************************************/ 5547 5548 xcb_void_cookie_t 5549 xcb_grab_server_checked (xcb_connection_t *c /**< */) 5550 { 5551 static const xcb_protocol_request_t xcb_req = { 5552 /* count */ 2, 5553 /* ext */ 0, 5554 /* opcode */ XCB_GRAB_SERVER, 5555 /* isvoid */ 1 5556 }; 5557 5558 struct iovec xcb_parts[4]; 5559 xcb_void_cookie_t xcb_ret; 5560 xcb_grab_server_request_t xcb_out; 5561 5562 xcb_out.pad0 = 0; 5563 5564 xcb_parts[2].iov_base = (char *) &xcb_out; 5565 xcb_parts[2].iov_len = sizeof(xcb_out); 5566 xcb_parts[3].iov_base = 0; 5567 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5568 5569 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5570 return xcb_ret; 5571 } 5572 5573 5574 /***************************************************************************** 5575 ** 5576 ** xcb_void_cookie_t xcb_grab_server 5577 ** 5578 ** @param xcb_connection_t *c 5579 ** @returns xcb_void_cookie_t 5580 ** 5581 *****************************************************************************/ 5582 5583 xcb_void_cookie_t 5584 xcb_grab_server (xcb_connection_t *c /**< */) 5585 { 5586 static const xcb_protocol_request_t xcb_req = { 5587 /* count */ 2, 5588 /* ext */ 0, 5589 /* opcode */ XCB_GRAB_SERVER, 5590 /* isvoid */ 1 5591 }; 5592 5593 struct iovec xcb_parts[4]; 5594 xcb_void_cookie_t xcb_ret; 5595 xcb_grab_server_request_t xcb_out; 5596 5597 xcb_out.pad0 = 0; 5598 5599 xcb_parts[2].iov_base = (char *) &xcb_out; 5600 xcb_parts[2].iov_len = sizeof(xcb_out); 5601 xcb_parts[3].iov_base = 0; 5602 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5603 5604 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5605 return xcb_ret; 5606 } 5607 5608 5609 /***************************************************************************** 5610 ** 5611 ** xcb_void_cookie_t xcb_ungrab_server_checked 5612 ** 5613 ** @param xcb_connection_t *c 5614 ** @returns xcb_void_cookie_t 5615 ** 5616 *****************************************************************************/ 5617 5618 xcb_void_cookie_t 5619 xcb_ungrab_server_checked (xcb_connection_t *c /**< */) 5620 { 5621 static const xcb_protocol_request_t xcb_req = { 5622 /* count */ 2, 5623 /* ext */ 0, 5624 /* opcode */ XCB_UNGRAB_SERVER, 5625 /* isvoid */ 1 5626 }; 5627 5628 struct iovec xcb_parts[4]; 5629 xcb_void_cookie_t xcb_ret; 5630 xcb_ungrab_server_request_t xcb_out; 5631 5632 xcb_out.pad0 = 0; 5633 5634 xcb_parts[2].iov_base = (char *) &xcb_out; 5635 xcb_parts[2].iov_len = sizeof(xcb_out); 5636 xcb_parts[3].iov_base = 0; 5637 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5638 5639 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5640 return xcb_ret; 5641 } 5642 5643 5644 /***************************************************************************** 5645 ** 5646 ** xcb_void_cookie_t xcb_ungrab_server 5647 ** 5648 ** @param xcb_connection_t *c 5649 ** @returns xcb_void_cookie_t 5650 ** 5651 *****************************************************************************/ 5652 5653 xcb_void_cookie_t 5654 xcb_ungrab_server (xcb_connection_t *c /**< */) 5655 { 5656 static const xcb_protocol_request_t xcb_req = { 5657 /* count */ 2, 5658 /* ext */ 0, 5659 /* opcode */ XCB_UNGRAB_SERVER, 5660 /* isvoid */ 1 5661 }; 5662 5663 struct iovec xcb_parts[4]; 5664 xcb_void_cookie_t xcb_ret; 5665 xcb_ungrab_server_request_t xcb_out; 5666 5667 xcb_out.pad0 = 0; 5668 5669 xcb_parts[2].iov_base = (char *) &xcb_out; 5670 xcb_parts[2].iov_len = sizeof(xcb_out); 5671 xcb_parts[3].iov_base = 0; 5672 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5673 5674 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5675 return xcb_ret; 5676 } 5677 5678 5679 /***************************************************************************** 5680 ** 5681 ** xcb_query_pointer_cookie_t xcb_query_pointer 5682 ** 5683 ** @param xcb_connection_t *c 5684 ** @param xcb_window_t window 5685 ** @returns xcb_query_pointer_cookie_t 5686 ** 5687 *****************************************************************************/ 5688 5689 xcb_query_pointer_cookie_t 5690 xcb_query_pointer (xcb_connection_t *c /**< */, 5691 xcb_window_t window /**< */) 5692 { 5693 static const xcb_protocol_request_t xcb_req = { 5694 /* count */ 2, 5695 /* ext */ 0, 5696 /* opcode */ XCB_QUERY_POINTER, 5697 /* isvoid */ 0 5698 }; 5699 5700 struct iovec xcb_parts[4]; 5701 xcb_query_pointer_cookie_t xcb_ret; 5702 xcb_query_pointer_request_t xcb_out; 5703 5704 xcb_out.pad0 = 0; 5705 xcb_out.window = window; 5706 5707 xcb_parts[2].iov_base = (char *) &xcb_out; 5708 xcb_parts[2].iov_len = sizeof(xcb_out); 5709 xcb_parts[3].iov_base = 0; 5710 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5711 5712 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5713 return xcb_ret; 5714 } 5715 5716 5717 /***************************************************************************** 5718 ** 5719 ** xcb_query_pointer_cookie_t xcb_query_pointer_unchecked 5720 ** 5721 ** @param xcb_connection_t *c 5722 ** @param xcb_window_t window 5723 ** @returns xcb_query_pointer_cookie_t 5724 ** 5725 *****************************************************************************/ 5726 5727 xcb_query_pointer_cookie_t 5728 xcb_query_pointer_unchecked (xcb_connection_t *c /**< */, 5729 xcb_window_t window /**< */) 5730 { 5731 static const xcb_protocol_request_t xcb_req = { 5732 /* count */ 2, 5733 /* ext */ 0, 5734 /* opcode */ XCB_QUERY_POINTER, 5735 /* isvoid */ 0 5736 }; 5737 5738 struct iovec xcb_parts[4]; 5739 xcb_query_pointer_cookie_t xcb_ret; 5740 xcb_query_pointer_request_t xcb_out; 5741 5742 xcb_out.pad0 = 0; 5743 xcb_out.window = window; 5744 5745 xcb_parts[2].iov_base = (char *) &xcb_out; 5746 xcb_parts[2].iov_len = sizeof(xcb_out); 5747 xcb_parts[3].iov_base = 0; 5748 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5749 5750 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5751 return xcb_ret; 5752 } 5753 5754 5755 /***************************************************************************** 5756 ** 5757 ** xcb_query_pointer_reply_t * xcb_query_pointer_reply 5758 ** 5759 ** @param xcb_connection_t *c 5760 ** @param xcb_query_pointer_cookie_t cookie 5761 ** @param xcb_generic_error_t **e 5762 ** @returns xcb_query_pointer_reply_t * 5763 ** 5764 *****************************************************************************/ 5765 5766 xcb_query_pointer_reply_t * 5767 xcb_query_pointer_reply (xcb_connection_t *c /**< */, 5768 xcb_query_pointer_cookie_t cookie /**< */, 5769 xcb_generic_error_t **e /**< */) 5770 { 5771 return (xcb_query_pointer_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5772 } 5773 5774 5775 /***************************************************************************** 5776 ** 5777 ** void xcb_timecoord_next 5778 ** 5779 ** @param xcb_timecoord_iterator_t *i 5780 ** @returns void 5781 ** 5782 *****************************************************************************/ 5783 5784 void 5785 xcb_timecoord_next (xcb_timecoord_iterator_t *i /**< */) 5786 { 5787 --i->rem; 5788 ++i->data; 5789 i->index += sizeof(xcb_timecoord_t); 5790 } 5791 5792 5793 /***************************************************************************** 5794 ** 5795 ** xcb_generic_iterator_t xcb_timecoord_end 5796 ** 5797 ** @param xcb_timecoord_iterator_t i 5798 ** @returns xcb_generic_iterator_t 5799 ** 5800 *****************************************************************************/ 5801 5802 xcb_generic_iterator_t 5803 xcb_timecoord_end (xcb_timecoord_iterator_t i /**< */) 5804 { 5805 xcb_generic_iterator_t ret; 5806 ret.data = i.data + i.rem; 5807 ret.index = i.index + ((char *) ret.data - (char *) i.data); 5808 ret.rem = 0; 5809 return ret; 5810 } 5811 5812 int 5813 xcb_get_motion_events_sizeof (const void *_buffer /**< */) 5814 { 5815 char *xcb_tmp = (char *)_buffer; 5816 const xcb_get_motion_events_reply_t *_aux = (xcb_get_motion_events_reply_t *)_buffer; 5817 unsigned int xcb_buffer_len = 0; 5818 unsigned int xcb_block_len = 0; 5819 unsigned int xcb_pad = 0; 5820 unsigned int xcb_align_to; 5821 5822 5823 xcb_block_len += sizeof(xcb_get_motion_events_reply_t); 5824 xcb_tmp += xcb_block_len; 5825 /* events */ 5826 xcb_block_len += _aux->events_len * sizeof(xcb_timecoord_t); 5827 xcb_tmp += xcb_block_len; 5828 xcb_align_to = ALIGNOF(xcb_timecoord_t); 5829 /* insert padding */ 5830 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 5831 xcb_buffer_len += xcb_block_len + xcb_pad; 5832 if (0 != xcb_pad) { 5833 xcb_tmp += xcb_pad; 5834 xcb_pad = 0; 5835 } 5836 xcb_block_len = 0; 5837 5838 return xcb_buffer_len; 5839 } 5840 5841 5842 /***************************************************************************** 5843 ** 5844 ** xcb_get_motion_events_cookie_t xcb_get_motion_events 5845 ** 5846 ** @param xcb_connection_t *c 5847 ** @param xcb_window_t window 5848 ** @param xcb_timestamp_t start 5849 ** @param xcb_timestamp_t stop 5850 ** @returns xcb_get_motion_events_cookie_t 5851 ** 5852 *****************************************************************************/ 5853 5854 xcb_get_motion_events_cookie_t 5855 xcb_get_motion_events (xcb_connection_t *c /**< */, 5856 xcb_window_t window /**< */, 5857 xcb_timestamp_t start /**< */, 5858 xcb_timestamp_t stop /**< */) 5859 { 5860 static const xcb_protocol_request_t xcb_req = { 5861 /* count */ 2, 5862 /* ext */ 0, 5863 /* opcode */ XCB_GET_MOTION_EVENTS, 5864 /* isvoid */ 0 5865 }; 5866 5867 struct iovec xcb_parts[4]; 5868 xcb_get_motion_events_cookie_t xcb_ret; 5869 xcb_get_motion_events_request_t xcb_out; 5870 5871 xcb_out.pad0 = 0; 5872 xcb_out.window = window; 5873 xcb_out.start = start; 5874 xcb_out.stop = stop; 5875 5876 xcb_parts[2].iov_base = (char *) &xcb_out; 5877 xcb_parts[2].iov_len = sizeof(xcb_out); 5878 xcb_parts[3].iov_base = 0; 5879 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5880 5881 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 5882 return xcb_ret; 5883 } 5884 5885 5886 /***************************************************************************** 5887 ** 5888 ** xcb_get_motion_events_cookie_t xcb_get_motion_events_unchecked 5889 ** 5890 ** @param xcb_connection_t *c 5891 ** @param xcb_window_t window 5892 ** @param xcb_timestamp_t start 5893 ** @param xcb_timestamp_t stop 5894 ** @returns xcb_get_motion_events_cookie_t 5895 ** 5896 *****************************************************************************/ 5897 5898 xcb_get_motion_events_cookie_t 5899 xcb_get_motion_events_unchecked (xcb_connection_t *c /**< */, 5900 xcb_window_t window /**< */, 5901 xcb_timestamp_t start /**< */, 5902 xcb_timestamp_t stop /**< */) 5903 { 5904 static const xcb_protocol_request_t xcb_req = { 5905 /* count */ 2, 5906 /* ext */ 0, 5907 /* opcode */ XCB_GET_MOTION_EVENTS, 5908 /* isvoid */ 0 5909 }; 5910 5911 struct iovec xcb_parts[4]; 5912 xcb_get_motion_events_cookie_t xcb_ret; 5913 xcb_get_motion_events_request_t xcb_out; 5914 5915 xcb_out.pad0 = 0; 5916 xcb_out.window = window; 5917 xcb_out.start = start; 5918 xcb_out.stop = stop; 5919 5920 xcb_parts[2].iov_base = (char *) &xcb_out; 5921 xcb_parts[2].iov_len = sizeof(xcb_out); 5922 xcb_parts[3].iov_base = 0; 5923 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 5924 5925 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 5926 return xcb_ret; 5927 } 5928 5929 5930 /***************************************************************************** 5931 ** 5932 ** xcb_timecoord_t * xcb_get_motion_events_events 5933 ** 5934 ** @param const xcb_get_motion_events_reply_t *R 5935 ** @returns xcb_timecoord_t * 5936 ** 5937 *****************************************************************************/ 5938 5939 xcb_timecoord_t * 5940 xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R /**< */) 5941 { 5942 return (xcb_timecoord_t *) (R + 1); 5943 } 5944 5945 5946 /***************************************************************************** 5947 ** 5948 ** int xcb_get_motion_events_events_length 5949 ** 5950 ** @param const xcb_get_motion_events_reply_t *R 5951 ** @returns int 5952 ** 5953 *****************************************************************************/ 5954 5955 int 5956 xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R /**< */) 5957 { 5958 return R->events_len; 5959 } 5960 5961 5962 /***************************************************************************** 5963 ** 5964 ** xcb_timecoord_iterator_t xcb_get_motion_events_events_iterator 5965 ** 5966 ** @param const xcb_get_motion_events_reply_t *R 5967 ** @returns xcb_timecoord_iterator_t 5968 ** 5969 *****************************************************************************/ 5970 5971 xcb_timecoord_iterator_t 5972 xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R /**< */) 5973 { 5974 xcb_timecoord_iterator_t i; 5975 i.data = (xcb_timecoord_t *) (R + 1); 5976 i.rem = R->events_len; 5977 i.index = (char *) i.data - (char *) R; 5978 return i; 5979 } 5980 5981 5982 /***************************************************************************** 5983 ** 5984 ** xcb_get_motion_events_reply_t * xcb_get_motion_events_reply 5985 ** 5986 ** @param xcb_connection_t *c 5987 ** @param xcb_get_motion_events_cookie_t cookie 5988 ** @param xcb_generic_error_t **e 5989 ** @returns xcb_get_motion_events_reply_t * 5990 ** 5991 *****************************************************************************/ 5992 5993 xcb_get_motion_events_reply_t * 5994 xcb_get_motion_events_reply (xcb_connection_t *c /**< */, 5995 xcb_get_motion_events_cookie_t cookie /**< */, 5996 xcb_generic_error_t **e /**< */) 5997 { 5998 return (xcb_get_motion_events_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 5999 } 6000 6001 6002 /***************************************************************************** 6003 ** 6004 ** xcb_translate_coordinates_cookie_t xcb_translate_coordinates 6005 ** 6006 ** @param xcb_connection_t *c 6007 ** @param xcb_window_t src_window 6008 ** @param xcb_window_t dst_window 6009 ** @param int16_t src_x 6010 ** @param int16_t src_y 6011 ** @returns xcb_translate_coordinates_cookie_t 6012 ** 6013 *****************************************************************************/ 6014 6015 xcb_translate_coordinates_cookie_t 6016 xcb_translate_coordinates (xcb_connection_t *c /**< */, 6017 xcb_window_t src_window /**< */, 6018 xcb_window_t dst_window /**< */, 6019 int16_t src_x /**< */, 6020 int16_t src_y /**< */) 6021 { 6022 static const xcb_protocol_request_t xcb_req = { 6023 /* count */ 2, 6024 /* ext */ 0, 6025 /* opcode */ XCB_TRANSLATE_COORDINATES, 6026 /* isvoid */ 0 6027 }; 6028 6029 struct iovec xcb_parts[4]; 6030 xcb_translate_coordinates_cookie_t xcb_ret; 6031 xcb_translate_coordinates_request_t xcb_out; 6032 6033 xcb_out.pad0 = 0; 6034 xcb_out.src_window = src_window; 6035 xcb_out.dst_window = dst_window; 6036 xcb_out.src_x = src_x; 6037 xcb_out.src_y = src_y; 6038 6039 xcb_parts[2].iov_base = (char *) &xcb_out; 6040 xcb_parts[2].iov_len = sizeof(xcb_out); 6041 xcb_parts[3].iov_base = 0; 6042 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6043 6044 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6045 return xcb_ret; 6046 } 6047 6048 6049 /***************************************************************************** 6050 ** 6051 ** xcb_translate_coordinates_cookie_t xcb_translate_coordinates_unchecked 6052 ** 6053 ** @param xcb_connection_t *c 6054 ** @param xcb_window_t src_window 6055 ** @param xcb_window_t dst_window 6056 ** @param int16_t src_x 6057 ** @param int16_t src_y 6058 ** @returns xcb_translate_coordinates_cookie_t 6059 ** 6060 *****************************************************************************/ 6061 6062 xcb_translate_coordinates_cookie_t 6063 xcb_translate_coordinates_unchecked (xcb_connection_t *c /**< */, 6064 xcb_window_t src_window /**< */, 6065 xcb_window_t dst_window /**< */, 6066 int16_t src_x /**< */, 6067 int16_t src_y /**< */) 6068 { 6069 static const xcb_protocol_request_t xcb_req = { 6070 /* count */ 2, 6071 /* ext */ 0, 6072 /* opcode */ XCB_TRANSLATE_COORDINATES, 6073 /* isvoid */ 0 6074 }; 6075 6076 struct iovec xcb_parts[4]; 6077 xcb_translate_coordinates_cookie_t xcb_ret; 6078 xcb_translate_coordinates_request_t xcb_out; 6079 6080 xcb_out.pad0 = 0; 6081 xcb_out.src_window = src_window; 6082 xcb_out.dst_window = dst_window; 6083 xcb_out.src_x = src_x; 6084 xcb_out.src_y = src_y; 6085 6086 xcb_parts[2].iov_base = (char *) &xcb_out; 6087 xcb_parts[2].iov_len = sizeof(xcb_out); 6088 xcb_parts[3].iov_base = 0; 6089 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6090 6091 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6092 return xcb_ret; 6093 } 6094 6095 6096 /***************************************************************************** 6097 ** 6098 ** xcb_translate_coordinates_reply_t * xcb_translate_coordinates_reply 6099 ** 6100 ** @param xcb_connection_t *c 6101 ** @param xcb_translate_coordinates_cookie_t cookie 6102 ** @param xcb_generic_error_t **e 6103 ** @returns xcb_translate_coordinates_reply_t * 6104 ** 6105 *****************************************************************************/ 6106 6107 xcb_translate_coordinates_reply_t * 6108 xcb_translate_coordinates_reply (xcb_connection_t *c /**< */, 6109 xcb_translate_coordinates_cookie_t cookie /**< */, 6110 xcb_generic_error_t **e /**< */) 6111 { 6112 return (xcb_translate_coordinates_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6113 } 6114 6115 6116 /***************************************************************************** 6117 ** 6118 ** xcb_void_cookie_t xcb_warp_pointer_checked 6119 ** 6120 ** @param xcb_connection_t *c 6121 ** @param xcb_window_t src_window 6122 ** @param xcb_window_t dst_window 6123 ** @param int16_t src_x 6124 ** @param int16_t src_y 6125 ** @param uint16_t src_width 6126 ** @param uint16_t src_height 6127 ** @param int16_t dst_x 6128 ** @param int16_t dst_y 6129 ** @returns xcb_void_cookie_t 6130 ** 6131 *****************************************************************************/ 6132 6133 xcb_void_cookie_t 6134 xcb_warp_pointer_checked (xcb_connection_t *c /**< */, 6135 xcb_window_t src_window /**< */, 6136 xcb_window_t dst_window /**< */, 6137 int16_t src_x /**< */, 6138 int16_t src_y /**< */, 6139 uint16_t src_width /**< */, 6140 uint16_t src_height /**< */, 6141 int16_t dst_x /**< */, 6142 int16_t dst_y /**< */) 6143 { 6144 static const xcb_protocol_request_t xcb_req = { 6145 /* count */ 2, 6146 /* ext */ 0, 6147 /* opcode */ XCB_WARP_POINTER, 6148 /* isvoid */ 1 6149 }; 6150 6151 struct iovec xcb_parts[4]; 6152 xcb_void_cookie_t xcb_ret; 6153 xcb_warp_pointer_request_t xcb_out; 6154 6155 xcb_out.pad0 = 0; 6156 xcb_out.src_window = src_window; 6157 xcb_out.dst_window = dst_window; 6158 xcb_out.src_x = src_x; 6159 xcb_out.src_y = src_y; 6160 xcb_out.src_width = src_width; 6161 xcb_out.src_height = src_height; 6162 xcb_out.dst_x = dst_x; 6163 xcb_out.dst_y = dst_y; 6164 6165 xcb_parts[2].iov_base = (char *) &xcb_out; 6166 xcb_parts[2].iov_len = sizeof(xcb_out); 6167 xcb_parts[3].iov_base = 0; 6168 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6169 6170 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6171 return xcb_ret; 6172 } 6173 6174 6175 /***************************************************************************** 6176 ** 6177 ** xcb_void_cookie_t xcb_warp_pointer 6178 ** 6179 ** @param xcb_connection_t *c 6180 ** @param xcb_window_t src_window 6181 ** @param xcb_window_t dst_window 6182 ** @param int16_t src_x 6183 ** @param int16_t src_y 6184 ** @param uint16_t src_width 6185 ** @param uint16_t src_height 6186 ** @param int16_t dst_x 6187 ** @param int16_t dst_y 6188 ** @returns xcb_void_cookie_t 6189 ** 6190 *****************************************************************************/ 6191 6192 xcb_void_cookie_t 6193 xcb_warp_pointer (xcb_connection_t *c /**< */, 6194 xcb_window_t src_window /**< */, 6195 xcb_window_t dst_window /**< */, 6196 int16_t src_x /**< */, 6197 int16_t src_y /**< */, 6198 uint16_t src_width /**< */, 6199 uint16_t src_height /**< */, 6200 int16_t dst_x /**< */, 6201 int16_t dst_y /**< */) 6202 { 6203 static const xcb_protocol_request_t xcb_req = { 6204 /* count */ 2, 6205 /* ext */ 0, 6206 /* opcode */ XCB_WARP_POINTER, 6207 /* isvoid */ 1 6208 }; 6209 6210 struct iovec xcb_parts[4]; 6211 xcb_void_cookie_t xcb_ret; 6212 xcb_warp_pointer_request_t xcb_out; 6213 6214 xcb_out.pad0 = 0; 6215 xcb_out.src_window = src_window; 6216 xcb_out.dst_window = dst_window; 6217 xcb_out.src_x = src_x; 6218 xcb_out.src_y = src_y; 6219 xcb_out.src_width = src_width; 6220 xcb_out.src_height = src_height; 6221 xcb_out.dst_x = dst_x; 6222 xcb_out.dst_y = dst_y; 6223 6224 xcb_parts[2].iov_base = (char *) &xcb_out; 6225 xcb_parts[2].iov_len = sizeof(xcb_out); 6226 xcb_parts[3].iov_base = 0; 6227 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6228 6229 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6230 return xcb_ret; 6231 } 6232 6233 6234 /***************************************************************************** 6235 ** 6236 ** xcb_void_cookie_t xcb_set_input_focus_checked 6237 ** 6238 ** @param xcb_connection_t *c 6239 ** @param uint8_t revert_to 6240 ** @param xcb_window_t focus 6241 ** @param xcb_timestamp_t time 6242 ** @returns xcb_void_cookie_t 6243 ** 6244 *****************************************************************************/ 6245 6246 xcb_void_cookie_t 6247 xcb_set_input_focus_checked (xcb_connection_t *c /**< */, 6248 uint8_t revert_to /**< */, 6249 xcb_window_t focus /**< */, 6250 xcb_timestamp_t time /**< */) 6251 { 6252 static const xcb_protocol_request_t xcb_req = { 6253 /* count */ 2, 6254 /* ext */ 0, 6255 /* opcode */ XCB_SET_INPUT_FOCUS, 6256 /* isvoid */ 1 6257 }; 6258 6259 struct iovec xcb_parts[4]; 6260 xcb_void_cookie_t xcb_ret; 6261 xcb_set_input_focus_request_t xcb_out; 6262 6263 xcb_out.revert_to = revert_to; 6264 xcb_out.focus = focus; 6265 xcb_out.time = time; 6266 6267 xcb_parts[2].iov_base = (char *) &xcb_out; 6268 xcb_parts[2].iov_len = sizeof(xcb_out); 6269 xcb_parts[3].iov_base = 0; 6270 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6271 6272 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6273 return xcb_ret; 6274 } 6275 6276 6277 /***************************************************************************** 6278 ** 6279 ** xcb_void_cookie_t xcb_set_input_focus 6280 ** 6281 ** @param xcb_connection_t *c 6282 ** @param uint8_t revert_to 6283 ** @param xcb_window_t focus 6284 ** @param xcb_timestamp_t time 6285 ** @returns xcb_void_cookie_t 6286 ** 6287 *****************************************************************************/ 6288 6289 xcb_void_cookie_t 6290 xcb_set_input_focus (xcb_connection_t *c /**< */, 6291 uint8_t revert_to /**< */, 6292 xcb_window_t focus /**< */, 6293 xcb_timestamp_t time /**< */) 6294 { 6295 static const xcb_protocol_request_t xcb_req = { 6296 /* count */ 2, 6297 /* ext */ 0, 6298 /* opcode */ XCB_SET_INPUT_FOCUS, 6299 /* isvoid */ 1 6300 }; 6301 6302 struct iovec xcb_parts[4]; 6303 xcb_void_cookie_t xcb_ret; 6304 xcb_set_input_focus_request_t xcb_out; 6305 6306 xcb_out.revert_to = revert_to; 6307 xcb_out.focus = focus; 6308 xcb_out.time = time; 6309 6310 xcb_parts[2].iov_base = (char *) &xcb_out; 6311 xcb_parts[2].iov_len = sizeof(xcb_out); 6312 xcb_parts[3].iov_base = 0; 6313 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6314 6315 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6316 return xcb_ret; 6317 } 6318 6319 6320 /***************************************************************************** 6321 ** 6322 ** xcb_get_input_focus_cookie_t xcb_get_input_focus 6323 ** 6324 ** @param xcb_connection_t *c 6325 ** @returns xcb_get_input_focus_cookie_t 6326 ** 6327 *****************************************************************************/ 6328 6329 xcb_get_input_focus_cookie_t 6330 xcb_get_input_focus (xcb_connection_t *c /**< */) 6331 { 6332 static const xcb_protocol_request_t xcb_req = { 6333 /* count */ 2, 6334 /* ext */ 0, 6335 /* opcode */ XCB_GET_INPUT_FOCUS, 6336 /* isvoid */ 0 6337 }; 6338 6339 struct iovec xcb_parts[4]; 6340 xcb_get_input_focus_cookie_t xcb_ret; 6341 xcb_get_input_focus_request_t xcb_out; 6342 6343 xcb_out.pad0 = 0; 6344 6345 xcb_parts[2].iov_base = (char *) &xcb_out; 6346 xcb_parts[2].iov_len = sizeof(xcb_out); 6347 xcb_parts[3].iov_base = 0; 6348 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6349 6350 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6351 return xcb_ret; 6352 } 6353 6354 6355 /***************************************************************************** 6356 ** 6357 ** xcb_get_input_focus_cookie_t xcb_get_input_focus_unchecked 6358 ** 6359 ** @param xcb_connection_t *c 6360 ** @returns xcb_get_input_focus_cookie_t 6361 ** 6362 *****************************************************************************/ 6363 6364 xcb_get_input_focus_cookie_t 6365 xcb_get_input_focus_unchecked (xcb_connection_t *c /**< */) 6366 { 6367 static const xcb_protocol_request_t xcb_req = { 6368 /* count */ 2, 6369 /* ext */ 0, 6370 /* opcode */ XCB_GET_INPUT_FOCUS, 6371 /* isvoid */ 0 6372 }; 6373 6374 struct iovec xcb_parts[4]; 6375 xcb_get_input_focus_cookie_t xcb_ret; 6376 xcb_get_input_focus_request_t xcb_out; 6377 6378 xcb_out.pad0 = 0; 6379 6380 xcb_parts[2].iov_base = (char *) &xcb_out; 6381 xcb_parts[2].iov_len = sizeof(xcb_out); 6382 xcb_parts[3].iov_base = 0; 6383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6384 6385 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6386 return xcb_ret; 6387 } 6388 6389 6390 /***************************************************************************** 6391 ** 6392 ** xcb_get_input_focus_reply_t * xcb_get_input_focus_reply 6393 ** 6394 ** @param xcb_connection_t *c 6395 ** @param xcb_get_input_focus_cookie_t cookie 6396 ** @param xcb_generic_error_t **e 6397 ** @returns xcb_get_input_focus_reply_t * 6398 ** 6399 *****************************************************************************/ 6400 6401 xcb_get_input_focus_reply_t * 6402 xcb_get_input_focus_reply (xcb_connection_t *c /**< */, 6403 xcb_get_input_focus_cookie_t cookie /**< */, 6404 xcb_generic_error_t **e /**< */) 6405 { 6406 return (xcb_get_input_focus_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6407 } 6408 6409 6410 /***************************************************************************** 6411 ** 6412 ** xcb_query_keymap_cookie_t xcb_query_keymap 6413 ** 6414 ** @param xcb_connection_t *c 6415 ** @returns xcb_query_keymap_cookie_t 6416 ** 6417 *****************************************************************************/ 6418 6419 xcb_query_keymap_cookie_t 6420 xcb_query_keymap (xcb_connection_t *c /**< */) 6421 { 6422 static const xcb_protocol_request_t xcb_req = { 6423 /* count */ 2, 6424 /* ext */ 0, 6425 /* opcode */ XCB_QUERY_KEYMAP, 6426 /* isvoid */ 0 6427 }; 6428 6429 struct iovec xcb_parts[4]; 6430 xcb_query_keymap_cookie_t xcb_ret; 6431 xcb_query_keymap_request_t xcb_out; 6432 6433 xcb_out.pad0 = 0; 6434 6435 xcb_parts[2].iov_base = (char *) &xcb_out; 6436 xcb_parts[2].iov_len = sizeof(xcb_out); 6437 xcb_parts[3].iov_base = 0; 6438 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6439 6440 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6441 return xcb_ret; 6442 } 6443 6444 6445 /***************************************************************************** 6446 ** 6447 ** xcb_query_keymap_cookie_t xcb_query_keymap_unchecked 6448 ** 6449 ** @param xcb_connection_t *c 6450 ** @returns xcb_query_keymap_cookie_t 6451 ** 6452 *****************************************************************************/ 6453 6454 xcb_query_keymap_cookie_t 6455 xcb_query_keymap_unchecked (xcb_connection_t *c /**< */) 6456 { 6457 static const xcb_protocol_request_t xcb_req = { 6458 /* count */ 2, 6459 /* ext */ 0, 6460 /* opcode */ XCB_QUERY_KEYMAP, 6461 /* isvoid */ 0 6462 }; 6463 6464 struct iovec xcb_parts[4]; 6465 xcb_query_keymap_cookie_t xcb_ret; 6466 xcb_query_keymap_request_t xcb_out; 6467 6468 xcb_out.pad0 = 0; 6469 6470 xcb_parts[2].iov_base = (char *) &xcb_out; 6471 xcb_parts[2].iov_len = sizeof(xcb_out); 6472 xcb_parts[3].iov_base = 0; 6473 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6474 6475 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6476 return xcb_ret; 6477 } 6478 6479 6480 /***************************************************************************** 6481 ** 6482 ** xcb_query_keymap_reply_t * xcb_query_keymap_reply 6483 ** 6484 ** @param xcb_connection_t *c 6485 ** @param xcb_query_keymap_cookie_t cookie 6486 ** @param xcb_generic_error_t **e 6487 ** @returns xcb_query_keymap_reply_t * 6488 ** 6489 *****************************************************************************/ 6490 6491 xcb_query_keymap_reply_t * 6492 xcb_query_keymap_reply (xcb_connection_t *c /**< */, 6493 xcb_query_keymap_cookie_t cookie /**< */, 6494 xcb_generic_error_t **e /**< */) 6495 { 6496 return (xcb_query_keymap_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 6497 } 6498 6499 int 6500 xcb_open_font_sizeof (const void *_buffer /**< */) 6501 { 6502 char *xcb_tmp = (char *)_buffer; 6503 const xcb_open_font_request_t *_aux = (xcb_open_font_request_t *)_buffer; 6504 unsigned int xcb_buffer_len = 0; 6505 unsigned int xcb_block_len = 0; 6506 unsigned int xcb_pad = 0; 6507 unsigned int xcb_align_to; 6508 6509 6510 xcb_block_len += sizeof(xcb_open_font_request_t); 6511 xcb_tmp += xcb_block_len; 6512 /* name */ 6513 xcb_block_len += _aux->name_len * sizeof(char); 6514 xcb_tmp += xcb_block_len; 6515 xcb_align_to = ALIGNOF(char); 6516 /* insert padding */ 6517 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6518 xcb_buffer_len += xcb_block_len + xcb_pad; 6519 if (0 != xcb_pad) { 6520 xcb_tmp += xcb_pad; 6521 xcb_pad = 0; 6522 } 6523 xcb_block_len = 0; 6524 6525 return xcb_buffer_len; 6526 } 6527 6528 6529 /***************************************************************************** 6530 ** 6531 ** xcb_void_cookie_t xcb_open_font_checked 6532 ** 6533 ** @param xcb_connection_t *c 6534 ** @param xcb_font_t fid 6535 ** @param uint16_t name_len 6536 ** @param const char *name 6537 ** @returns xcb_void_cookie_t 6538 ** 6539 *****************************************************************************/ 6540 6541 xcb_void_cookie_t 6542 xcb_open_font_checked (xcb_connection_t *c /**< */, 6543 xcb_font_t fid /**< */, 6544 uint16_t name_len /**< */, 6545 const char *name /**< */) 6546 { 6547 static const xcb_protocol_request_t xcb_req = { 6548 /* count */ 4, 6549 /* ext */ 0, 6550 /* opcode */ XCB_OPEN_FONT, 6551 /* isvoid */ 1 6552 }; 6553 6554 struct iovec xcb_parts[6]; 6555 xcb_void_cookie_t xcb_ret; 6556 xcb_open_font_request_t xcb_out; 6557 6558 xcb_out.pad0 = 0; 6559 xcb_out.fid = fid; 6560 xcb_out.name_len = name_len; 6561 memset(xcb_out.pad1, 0, 2); 6562 6563 xcb_parts[2].iov_base = (char *) &xcb_out; 6564 xcb_parts[2].iov_len = sizeof(xcb_out); 6565 xcb_parts[3].iov_base = 0; 6566 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6567 /* char name */ 6568 xcb_parts[4].iov_base = (char *) name; 6569 xcb_parts[4].iov_len = name_len * sizeof(char); 6570 xcb_parts[5].iov_base = 0; 6571 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 6572 6573 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6574 return xcb_ret; 6575 } 6576 6577 6578 /***************************************************************************** 6579 ** 6580 ** xcb_void_cookie_t xcb_open_font 6581 ** 6582 ** @param xcb_connection_t *c 6583 ** @param xcb_font_t fid 6584 ** @param uint16_t name_len 6585 ** @param const char *name 6586 ** @returns xcb_void_cookie_t 6587 ** 6588 *****************************************************************************/ 6589 6590 xcb_void_cookie_t 6591 xcb_open_font (xcb_connection_t *c /**< */, 6592 xcb_font_t fid /**< */, 6593 uint16_t name_len /**< */, 6594 const char *name /**< */) 6595 { 6596 static const xcb_protocol_request_t xcb_req = { 6597 /* count */ 4, 6598 /* ext */ 0, 6599 /* opcode */ XCB_OPEN_FONT, 6600 /* isvoid */ 1 6601 }; 6602 6603 struct iovec xcb_parts[6]; 6604 xcb_void_cookie_t xcb_ret; 6605 xcb_open_font_request_t xcb_out; 6606 6607 xcb_out.pad0 = 0; 6608 xcb_out.fid = fid; 6609 xcb_out.name_len = name_len; 6610 memset(xcb_out.pad1, 0, 2); 6611 6612 xcb_parts[2].iov_base = (char *) &xcb_out; 6613 xcb_parts[2].iov_len = sizeof(xcb_out); 6614 xcb_parts[3].iov_base = 0; 6615 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6616 /* char name */ 6617 xcb_parts[4].iov_base = (char *) name; 6618 xcb_parts[4].iov_len = name_len * sizeof(char); 6619 xcb_parts[5].iov_base = 0; 6620 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 6621 6622 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6623 return xcb_ret; 6624 } 6625 6626 6627 /***************************************************************************** 6628 ** 6629 ** xcb_void_cookie_t xcb_close_font_checked 6630 ** 6631 ** @param xcb_connection_t *c 6632 ** @param xcb_font_t font 6633 ** @returns xcb_void_cookie_t 6634 ** 6635 *****************************************************************************/ 6636 6637 xcb_void_cookie_t 6638 xcb_close_font_checked (xcb_connection_t *c /**< */, 6639 xcb_font_t font /**< */) 6640 { 6641 static const xcb_protocol_request_t xcb_req = { 6642 /* count */ 2, 6643 /* ext */ 0, 6644 /* opcode */ XCB_CLOSE_FONT, 6645 /* isvoid */ 1 6646 }; 6647 6648 struct iovec xcb_parts[4]; 6649 xcb_void_cookie_t xcb_ret; 6650 xcb_close_font_request_t xcb_out; 6651 6652 xcb_out.pad0 = 0; 6653 xcb_out.font = font; 6654 6655 xcb_parts[2].iov_base = (char *) &xcb_out; 6656 xcb_parts[2].iov_len = sizeof(xcb_out); 6657 xcb_parts[3].iov_base = 0; 6658 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6659 6660 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6661 return xcb_ret; 6662 } 6663 6664 6665 /***************************************************************************** 6666 ** 6667 ** xcb_void_cookie_t xcb_close_font 6668 ** 6669 ** @param xcb_connection_t *c 6670 ** @param xcb_font_t font 6671 ** @returns xcb_void_cookie_t 6672 ** 6673 *****************************************************************************/ 6674 6675 xcb_void_cookie_t 6676 xcb_close_font (xcb_connection_t *c /**< */, 6677 xcb_font_t font /**< */) 6678 { 6679 static const xcb_protocol_request_t xcb_req = { 6680 /* count */ 2, 6681 /* ext */ 0, 6682 /* opcode */ XCB_CLOSE_FONT, 6683 /* isvoid */ 1 6684 }; 6685 6686 struct iovec xcb_parts[4]; 6687 xcb_void_cookie_t xcb_ret; 6688 xcb_close_font_request_t xcb_out; 6689 6690 xcb_out.pad0 = 0; 6691 xcb_out.font = font; 6692 6693 xcb_parts[2].iov_base = (char *) &xcb_out; 6694 xcb_parts[2].iov_len = sizeof(xcb_out); 6695 xcb_parts[3].iov_base = 0; 6696 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6697 6698 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6699 return xcb_ret; 6700 } 6701 6702 6703 /***************************************************************************** 6704 ** 6705 ** void xcb_fontprop_next 6706 ** 6707 ** @param xcb_fontprop_iterator_t *i 6708 ** @returns void 6709 ** 6710 *****************************************************************************/ 6711 6712 void 6713 xcb_fontprop_next (xcb_fontprop_iterator_t *i /**< */) 6714 { 6715 --i->rem; 6716 ++i->data; 6717 i->index += sizeof(xcb_fontprop_t); 6718 } 6719 6720 6721 /***************************************************************************** 6722 ** 6723 ** xcb_generic_iterator_t xcb_fontprop_end 6724 ** 6725 ** @param xcb_fontprop_iterator_t i 6726 ** @returns xcb_generic_iterator_t 6727 ** 6728 *****************************************************************************/ 6729 6730 xcb_generic_iterator_t 6731 xcb_fontprop_end (xcb_fontprop_iterator_t i /**< */) 6732 { 6733 xcb_generic_iterator_t ret; 6734 ret.data = i.data + i.rem; 6735 ret.index = i.index + ((char *) ret.data - (char *) i.data); 6736 ret.rem = 0; 6737 return ret; 6738 } 6739 6740 6741 /***************************************************************************** 6742 ** 6743 ** void xcb_charinfo_next 6744 ** 6745 ** @param xcb_charinfo_iterator_t *i 6746 ** @returns void 6747 ** 6748 *****************************************************************************/ 6749 6750 void 6751 xcb_charinfo_next (xcb_charinfo_iterator_t *i /**< */) 6752 { 6753 --i->rem; 6754 ++i->data; 6755 i->index += sizeof(xcb_charinfo_t); 6756 } 6757 6758 6759 /***************************************************************************** 6760 ** 6761 ** xcb_generic_iterator_t xcb_charinfo_end 6762 ** 6763 ** @param xcb_charinfo_iterator_t i 6764 ** @returns xcb_generic_iterator_t 6765 ** 6766 *****************************************************************************/ 6767 6768 xcb_generic_iterator_t 6769 xcb_charinfo_end (xcb_charinfo_iterator_t i /**< */) 6770 { 6771 xcb_generic_iterator_t ret; 6772 ret.data = i.data + i.rem; 6773 ret.index = i.index + ((char *) ret.data - (char *) i.data); 6774 ret.rem = 0; 6775 return ret; 6776 } 6777 6778 int 6779 xcb_query_font_sizeof (const void *_buffer /**< */) 6780 { 6781 char *xcb_tmp = (char *)_buffer; 6782 const xcb_query_font_reply_t *_aux = (xcb_query_font_reply_t *)_buffer; 6783 unsigned int xcb_buffer_len = 0; 6784 unsigned int xcb_block_len = 0; 6785 unsigned int xcb_pad = 0; 6786 unsigned int xcb_align_to; 6787 6788 6789 xcb_block_len += sizeof(xcb_query_font_reply_t); 6790 xcb_tmp += xcb_block_len; 6791 /* properties */ 6792 xcb_block_len += _aux->properties_len * sizeof(xcb_fontprop_t); 6793 xcb_tmp += xcb_block_len; 6794 xcb_align_to = ALIGNOF(xcb_fontprop_t); 6795 /* insert padding */ 6796 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6797 xcb_buffer_len += xcb_block_len + xcb_pad; 6798 if (0 != xcb_pad) { 6799 xcb_tmp += xcb_pad; 6800 xcb_pad = 0; 6801 } 6802 xcb_block_len = 0; 6803 /* char_infos */ 6804 xcb_block_len += _aux->char_infos_len * sizeof(xcb_charinfo_t); 6805 xcb_tmp += xcb_block_len; 6806 xcb_align_to = ALIGNOF(xcb_charinfo_t); 6807 /* insert padding */ 6808 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 6809 xcb_buffer_len += xcb_block_len + xcb_pad; 6810 if (0 != xcb_pad) { 6811 xcb_tmp += xcb_pad; 6812 xcb_pad = 0; 6813 } 6814 xcb_block_len = 0; 6815 6816 return xcb_buffer_len; 6817 } 6818 6819 6820 /***************************************************************************** 6821 ** 6822 ** xcb_query_font_cookie_t xcb_query_font 6823 ** 6824 ** @param xcb_connection_t *c 6825 ** @param xcb_fontable_t font 6826 ** @returns xcb_query_font_cookie_t 6827 ** 6828 *****************************************************************************/ 6829 6830 xcb_query_font_cookie_t 6831 xcb_query_font (xcb_connection_t *c /**< */, 6832 xcb_fontable_t font /**< */) 6833 { 6834 static const xcb_protocol_request_t xcb_req = { 6835 /* count */ 2, 6836 /* ext */ 0, 6837 /* opcode */ XCB_QUERY_FONT, 6838 /* isvoid */ 0 6839 }; 6840 6841 struct iovec xcb_parts[4]; 6842 xcb_query_font_cookie_t xcb_ret; 6843 xcb_query_font_request_t xcb_out; 6844 6845 xcb_out.pad0 = 0; 6846 xcb_out.font = font; 6847 6848 xcb_parts[2].iov_base = (char *) &xcb_out; 6849 xcb_parts[2].iov_len = sizeof(xcb_out); 6850 xcb_parts[3].iov_base = 0; 6851 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6852 6853 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 6854 return xcb_ret; 6855 } 6856 6857 6858 /***************************************************************************** 6859 ** 6860 ** xcb_query_font_cookie_t xcb_query_font_unchecked 6861 ** 6862 ** @param xcb_connection_t *c 6863 ** @param xcb_fontable_t font 6864 ** @returns xcb_query_font_cookie_t 6865 ** 6866 *****************************************************************************/ 6867 6868 xcb_query_font_cookie_t 6869 xcb_query_font_unchecked (xcb_connection_t *c /**< */, 6870 xcb_fontable_t font /**< */) 6871 { 6872 static const xcb_protocol_request_t xcb_req = { 6873 /* count */ 2, 6874 /* ext */ 0, 6875 /* opcode */ XCB_QUERY_FONT, 6876 /* isvoid */ 0 6877 }; 6878 6879 struct iovec xcb_parts[4]; 6880 xcb_query_font_cookie_t xcb_ret; 6881 xcb_query_font_request_t xcb_out; 6882 6883 xcb_out.pad0 = 0; 6884 xcb_out.font = font; 6885 6886 xcb_parts[2].iov_base = (char *) &xcb_out; 6887 xcb_parts[2].iov_len = sizeof(xcb_out); 6888 xcb_parts[3].iov_base = 0; 6889 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 6890 6891 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 6892 return xcb_ret; 6893 } 6894 6895 6896 /***************************************************************************** 6897 ** 6898 ** xcb_fontprop_t * xcb_query_font_properties 6899 ** 6900 ** @param const xcb_query_font_reply_t *R 6901 ** @returns xcb_fontprop_t * 6902 ** 6903 *****************************************************************************/ 6904 6905 xcb_fontprop_t * 6906 xcb_query_font_properties (const xcb_query_font_reply_t *R /**< */) 6907 { 6908 return (xcb_fontprop_t *) (R + 1); 6909 } 6910 6911 6912 /***************************************************************************** 6913 ** 6914 ** int xcb_query_font_properties_length 6915 ** 6916 ** @param const xcb_query_font_reply_t *R 6917 ** @returns int 6918 ** 6919 *****************************************************************************/ 6920 6921 int 6922 xcb_query_font_properties_length (const xcb_query_font_reply_t *R /**< */) 6923 { 6924 return R->properties_len; 6925 } 6926 6927 6928 /***************************************************************************** 6929 ** 6930 ** xcb_fontprop_iterator_t xcb_query_font_properties_iterator 6931 ** 6932 ** @param const xcb_query_font_reply_t *R 6933 ** @returns xcb_fontprop_iterator_t 6934 ** 6935 *****************************************************************************/ 6936 6937 xcb_fontprop_iterator_t 6938 xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R /**< */) 6939 { 6940 xcb_fontprop_iterator_t i; 6941 i.data = (xcb_fontprop_t *) (R + 1); 6942 i.rem = R->properties_len; 6943 i.index = (char *) i.data - (char *) R; 6944 return i; 6945 } 6946 6947 6948 /***************************************************************************** 6949 ** 6950 ** xcb_charinfo_t * xcb_query_font_char_infos 6951 ** 6952 ** @param const xcb_query_font_reply_t *R 6953 ** @returns xcb_charinfo_t * 6954 ** 6955 *****************************************************************************/ 6956 6957 xcb_charinfo_t * 6958 xcb_query_font_char_infos (const xcb_query_font_reply_t *R /**< */) 6959 { 6960 xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R)); 6961 return (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index) + 0); 6962 } 6963 6964 6965 /***************************************************************************** 6966 ** 6967 ** int xcb_query_font_char_infos_length 6968 ** 6969 ** @param const xcb_query_font_reply_t *R 6970 ** @returns int 6971 ** 6972 *****************************************************************************/ 6973 6974 int 6975 xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R /**< */) 6976 { 6977 return R->char_infos_len; 6978 } 6979 6980 6981 /***************************************************************************** 6982 ** 6983 ** xcb_charinfo_iterator_t xcb_query_font_char_infos_iterator 6984 ** 6985 ** @param const xcb_query_font_reply_t *R 6986 ** @returns xcb_charinfo_iterator_t 6987 ** 6988 *****************************************************************************/ 6989 6990 xcb_charinfo_iterator_t 6991 xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R /**< */) 6992 { 6993 xcb_charinfo_iterator_t i; 6994 xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_query_font_properties_iterator(R)); 6995 i.data = (xcb_charinfo_t *) ((char *) prev.data + XCB_TYPE_PAD(xcb_charinfo_t, prev.index)); 6996 i.rem = R->char_infos_len; 6997 i.index = (char *) i.data - (char *) R; 6998 return i; 6999 } 7000 7001 7002 /***************************************************************************** 7003 ** 7004 ** xcb_query_font_reply_t * xcb_query_font_reply 7005 ** 7006 ** @param xcb_connection_t *c 7007 ** @param xcb_query_font_cookie_t cookie 7008 ** @param xcb_generic_error_t **e 7009 ** @returns xcb_query_font_reply_t * 7010 ** 7011 *****************************************************************************/ 7012 7013 xcb_query_font_reply_t * 7014 xcb_query_font_reply (xcb_connection_t *c /**< */, 7015 xcb_query_font_cookie_t cookie /**< */, 7016 xcb_generic_error_t **e /**< */) 7017 { 7018 return (xcb_query_font_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7019 } 7020 7021 int 7022 xcb_query_text_extents_sizeof (const void *_buffer /**< */, 7023 uint32_t string_len /**< */) 7024 { 7025 char *xcb_tmp = (char *)_buffer; 7026 unsigned int xcb_buffer_len = 0; 7027 unsigned int xcb_block_len = 0; 7028 unsigned int xcb_pad = 0; 7029 unsigned int xcb_align_to; 7030 7031 7032 xcb_block_len += sizeof(xcb_query_text_extents_request_t); 7033 xcb_tmp += xcb_block_len; 7034 /* string */ 7035 xcb_block_len += string_len * sizeof(xcb_char2b_t); 7036 xcb_tmp += xcb_block_len; 7037 xcb_align_to = ALIGNOF(xcb_char2b_t); 7038 /* insert padding */ 7039 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7040 xcb_buffer_len += xcb_block_len + xcb_pad; 7041 if (0 != xcb_pad) { 7042 xcb_tmp += xcb_pad; 7043 xcb_pad = 0; 7044 } 7045 xcb_block_len = 0; 7046 7047 return xcb_buffer_len; 7048 } 7049 7050 7051 /***************************************************************************** 7052 ** 7053 ** xcb_query_text_extents_cookie_t xcb_query_text_extents 7054 ** 7055 ** @param xcb_connection_t *c 7056 ** @param xcb_fontable_t font 7057 ** @param uint32_t string_len 7058 ** @param const xcb_char2b_t *string 7059 ** @returns xcb_query_text_extents_cookie_t 7060 ** 7061 *****************************************************************************/ 7062 7063 xcb_query_text_extents_cookie_t 7064 xcb_query_text_extents (xcb_connection_t *c /**< */, 7065 xcb_fontable_t font /**< */, 7066 uint32_t string_len /**< */, 7067 const xcb_char2b_t *string /**< */) 7068 { 7069 static const xcb_protocol_request_t xcb_req = { 7070 /* count */ 4, 7071 /* ext */ 0, 7072 /* opcode */ XCB_QUERY_TEXT_EXTENTS, 7073 /* isvoid */ 0 7074 }; 7075 7076 struct iovec xcb_parts[6]; 7077 xcb_query_text_extents_cookie_t xcb_ret; 7078 xcb_query_text_extents_request_t xcb_out; 7079 7080 xcb_out.odd_length = (string_len & 1); 7081 xcb_out.font = font; 7082 7083 xcb_parts[2].iov_base = (char *) &xcb_out; 7084 xcb_parts[2].iov_len = sizeof(xcb_out); 7085 xcb_parts[3].iov_base = 0; 7086 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7087 /* xcb_char2b_t string */ 7088 xcb_parts[4].iov_base = (char *) string; 7089 xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t); 7090 xcb_parts[5].iov_base = 0; 7091 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7092 7093 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7094 return xcb_ret; 7095 } 7096 7097 7098 /***************************************************************************** 7099 ** 7100 ** xcb_query_text_extents_cookie_t xcb_query_text_extents_unchecked 7101 ** 7102 ** @param xcb_connection_t *c 7103 ** @param xcb_fontable_t font 7104 ** @param uint32_t string_len 7105 ** @param const xcb_char2b_t *string 7106 ** @returns xcb_query_text_extents_cookie_t 7107 ** 7108 *****************************************************************************/ 7109 7110 xcb_query_text_extents_cookie_t 7111 xcb_query_text_extents_unchecked (xcb_connection_t *c /**< */, 7112 xcb_fontable_t font /**< */, 7113 uint32_t string_len /**< */, 7114 const xcb_char2b_t *string /**< */) 7115 { 7116 static const xcb_protocol_request_t xcb_req = { 7117 /* count */ 4, 7118 /* ext */ 0, 7119 /* opcode */ XCB_QUERY_TEXT_EXTENTS, 7120 /* isvoid */ 0 7121 }; 7122 7123 struct iovec xcb_parts[6]; 7124 xcb_query_text_extents_cookie_t xcb_ret; 7125 xcb_query_text_extents_request_t xcb_out; 7126 7127 xcb_out.odd_length = (string_len & 1); 7128 xcb_out.font = font; 7129 7130 xcb_parts[2].iov_base = (char *) &xcb_out; 7131 xcb_parts[2].iov_len = sizeof(xcb_out); 7132 xcb_parts[3].iov_base = 0; 7133 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7134 /* xcb_char2b_t string */ 7135 xcb_parts[4].iov_base = (char *) string; 7136 xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t); 7137 xcb_parts[5].iov_base = 0; 7138 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7139 7140 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7141 return xcb_ret; 7142 } 7143 7144 7145 /***************************************************************************** 7146 ** 7147 ** xcb_query_text_extents_reply_t * xcb_query_text_extents_reply 7148 ** 7149 ** @param xcb_connection_t *c 7150 ** @param xcb_query_text_extents_cookie_t cookie 7151 ** @param xcb_generic_error_t **e 7152 ** @returns xcb_query_text_extents_reply_t * 7153 ** 7154 *****************************************************************************/ 7155 7156 xcb_query_text_extents_reply_t * 7157 xcb_query_text_extents_reply (xcb_connection_t *c /**< */, 7158 xcb_query_text_extents_cookie_t cookie /**< */, 7159 xcb_generic_error_t **e /**< */) 7160 { 7161 return (xcb_query_text_extents_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7162 } 7163 7164 int 7165 xcb_str_sizeof (const void *_buffer /**< */) 7166 { 7167 char *xcb_tmp = (char *)_buffer; 7168 const xcb_str_t *_aux = (xcb_str_t *)_buffer; 7169 unsigned int xcb_buffer_len = 0; 7170 unsigned int xcb_block_len = 0; 7171 unsigned int xcb_pad = 0; 7172 unsigned int xcb_align_to; 7173 7174 7175 xcb_block_len += sizeof(xcb_str_t); 7176 xcb_tmp += xcb_block_len; 7177 /* name */ 7178 xcb_block_len += _aux->name_len * sizeof(char); 7179 xcb_tmp += xcb_block_len; 7180 xcb_align_to = ALIGNOF(char); 7181 /* insert padding */ 7182 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7183 xcb_buffer_len += xcb_block_len + xcb_pad; 7184 if (0 != xcb_pad) { 7185 xcb_tmp += xcb_pad; 7186 xcb_pad = 0; 7187 } 7188 xcb_block_len = 0; 7189 7190 return xcb_buffer_len; 7191 } 7192 7193 7194 /***************************************************************************** 7195 ** 7196 ** char * xcb_str_name 7197 ** 7198 ** @param const xcb_str_t *R 7199 ** @returns char * 7200 ** 7201 *****************************************************************************/ 7202 7203 char * 7204 xcb_str_name (const xcb_str_t *R /**< */) 7205 { 7206 return (char *) (R + 1); 7207 } 7208 7209 7210 /***************************************************************************** 7211 ** 7212 ** int xcb_str_name_length 7213 ** 7214 ** @param const xcb_str_t *R 7215 ** @returns int 7216 ** 7217 *****************************************************************************/ 7218 7219 int 7220 xcb_str_name_length (const xcb_str_t *R /**< */) 7221 { 7222 return R->name_len; 7223 } 7224 7225 7226 /***************************************************************************** 7227 ** 7228 ** xcb_generic_iterator_t xcb_str_name_end 7229 ** 7230 ** @param const xcb_str_t *R 7231 ** @returns xcb_generic_iterator_t 7232 ** 7233 *****************************************************************************/ 7234 7235 xcb_generic_iterator_t 7236 xcb_str_name_end (const xcb_str_t *R /**< */) 7237 { 7238 xcb_generic_iterator_t i; 7239 i.data = ((char *) (R + 1)) + (R->name_len); 7240 i.rem = 0; 7241 i.index = (char *) i.data - (char *) R; 7242 return i; 7243 } 7244 7245 7246 /***************************************************************************** 7247 ** 7248 ** void xcb_str_next 7249 ** 7250 ** @param xcb_str_iterator_t *i 7251 ** @returns void 7252 ** 7253 *****************************************************************************/ 7254 7255 void 7256 xcb_str_next (xcb_str_iterator_t *i /**< */) 7257 { 7258 xcb_str_t *R = i->data; 7259 xcb_generic_iterator_t child; 7260 child.data = (xcb_str_t *)(((char *)R) + xcb_str_sizeof(R)); 7261 i->index = (char *) child.data - (char *) i->data; 7262 --i->rem; 7263 i->data = (xcb_str_t *) child.data; 7264 } 7265 7266 7267 /***************************************************************************** 7268 ** 7269 ** xcb_generic_iterator_t xcb_str_end 7270 ** 7271 ** @param xcb_str_iterator_t i 7272 ** @returns xcb_generic_iterator_t 7273 ** 7274 *****************************************************************************/ 7275 7276 xcb_generic_iterator_t 7277 xcb_str_end (xcb_str_iterator_t i /**< */) 7278 { 7279 xcb_generic_iterator_t ret; 7280 while(i.rem > 0) 7281 xcb_str_next(&i); 7282 ret.data = i.data; 7283 ret.rem = i.rem; 7284 ret.index = i.index; 7285 return ret; 7286 } 7287 7288 int 7289 xcb_list_fonts_sizeof (const void *_buffer /**< */) 7290 { 7291 char *xcb_tmp = (char *)_buffer; 7292 const xcb_list_fonts_request_t *_aux = (xcb_list_fonts_request_t *)_buffer; 7293 unsigned int xcb_buffer_len = 0; 7294 unsigned int xcb_block_len = 0; 7295 unsigned int xcb_pad = 0; 7296 unsigned int xcb_align_to; 7297 7298 7299 xcb_block_len += sizeof(xcb_list_fonts_request_t); 7300 xcb_tmp += xcb_block_len; 7301 /* pattern */ 7302 xcb_block_len += _aux->pattern_len * sizeof(char); 7303 xcb_tmp += xcb_block_len; 7304 xcb_align_to = ALIGNOF(char); 7305 /* insert padding */ 7306 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7307 xcb_buffer_len += xcb_block_len + xcb_pad; 7308 if (0 != xcb_pad) { 7309 xcb_tmp += xcb_pad; 7310 xcb_pad = 0; 7311 } 7312 xcb_block_len = 0; 7313 7314 return xcb_buffer_len; 7315 } 7316 7317 7318 /***************************************************************************** 7319 ** 7320 ** xcb_list_fonts_cookie_t xcb_list_fonts 7321 ** 7322 ** @param xcb_connection_t *c 7323 ** @param uint16_t max_names 7324 ** @param uint16_t pattern_len 7325 ** @param const char *pattern 7326 ** @returns xcb_list_fonts_cookie_t 7327 ** 7328 *****************************************************************************/ 7329 7330 xcb_list_fonts_cookie_t 7331 xcb_list_fonts (xcb_connection_t *c /**< */, 7332 uint16_t max_names /**< */, 7333 uint16_t pattern_len /**< */, 7334 const char *pattern /**< */) 7335 { 7336 static const xcb_protocol_request_t xcb_req = { 7337 /* count */ 4, 7338 /* ext */ 0, 7339 /* opcode */ XCB_LIST_FONTS, 7340 /* isvoid */ 0 7341 }; 7342 7343 struct iovec xcb_parts[6]; 7344 xcb_list_fonts_cookie_t xcb_ret; 7345 xcb_list_fonts_request_t xcb_out; 7346 7347 xcb_out.pad0 = 0; 7348 xcb_out.max_names = max_names; 7349 xcb_out.pattern_len = pattern_len; 7350 7351 xcb_parts[2].iov_base = (char *) &xcb_out; 7352 xcb_parts[2].iov_len = sizeof(xcb_out); 7353 xcb_parts[3].iov_base = 0; 7354 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7355 /* char pattern */ 7356 xcb_parts[4].iov_base = (char *) pattern; 7357 xcb_parts[4].iov_len = pattern_len * sizeof(char); 7358 xcb_parts[5].iov_base = 0; 7359 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7360 7361 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7362 return xcb_ret; 7363 } 7364 7365 7366 /***************************************************************************** 7367 ** 7368 ** xcb_list_fonts_cookie_t xcb_list_fonts_unchecked 7369 ** 7370 ** @param xcb_connection_t *c 7371 ** @param uint16_t max_names 7372 ** @param uint16_t pattern_len 7373 ** @param const char *pattern 7374 ** @returns xcb_list_fonts_cookie_t 7375 ** 7376 *****************************************************************************/ 7377 7378 xcb_list_fonts_cookie_t 7379 xcb_list_fonts_unchecked (xcb_connection_t *c /**< */, 7380 uint16_t max_names /**< */, 7381 uint16_t pattern_len /**< */, 7382 const char *pattern /**< */) 7383 { 7384 static const xcb_protocol_request_t xcb_req = { 7385 /* count */ 4, 7386 /* ext */ 0, 7387 /* opcode */ XCB_LIST_FONTS, 7388 /* isvoid */ 0 7389 }; 7390 7391 struct iovec xcb_parts[6]; 7392 xcb_list_fonts_cookie_t xcb_ret; 7393 xcb_list_fonts_request_t xcb_out; 7394 7395 xcb_out.pad0 = 0; 7396 xcb_out.max_names = max_names; 7397 xcb_out.pattern_len = pattern_len; 7398 7399 xcb_parts[2].iov_base = (char *) &xcb_out; 7400 xcb_parts[2].iov_len = sizeof(xcb_out); 7401 xcb_parts[3].iov_base = 0; 7402 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7403 /* char pattern */ 7404 xcb_parts[4].iov_base = (char *) pattern; 7405 xcb_parts[4].iov_len = pattern_len * sizeof(char); 7406 xcb_parts[5].iov_base = 0; 7407 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7408 7409 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7410 return xcb_ret; 7411 } 7412 7413 7414 /***************************************************************************** 7415 ** 7416 ** int xcb_list_fonts_names_length 7417 ** 7418 ** @param const xcb_list_fonts_reply_t *R 7419 ** @returns int 7420 ** 7421 *****************************************************************************/ 7422 7423 int 7424 xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R /**< */) 7425 { 7426 return R->names_len; 7427 } 7428 7429 7430 /***************************************************************************** 7431 ** 7432 ** xcb_str_iterator_t xcb_list_fonts_names_iterator 7433 ** 7434 ** @param const xcb_list_fonts_reply_t *R 7435 ** @returns xcb_str_iterator_t 7436 ** 7437 *****************************************************************************/ 7438 7439 xcb_str_iterator_t 7440 xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R /**< */) 7441 { 7442 xcb_str_iterator_t i; 7443 i.data = (xcb_str_t *) (R + 1); 7444 i.rem = R->names_len; 7445 i.index = (char *) i.data - (char *) R; 7446 return i; 7447 } 7448 7449 7450 /***************************************************************************** 7451 ** 7452 ** xcb_list_fonts_reply_t * xcb_list_fonts_reply 7453 ** 7454 ** @param xcb_connection_t *c 7455 ** @param xcb_list_fonts_cookie_t cookie 7456 ** @param xcb_generic_error_t **e 7457 ** @returns xcb_list_fonts_reply_t * 7458 ** 7459 *****************************************************************************/ 7460 7461 xcb_list_fonts_reply_t * 7462 xcb_list_fonts_reply (xcb_connection_t *c /**< */, 7463 xcb_list_fonts_cookie_t cookie /**< */, 7464 xcb_generic_error_t **e /**< */) 7465 { 7466 return (xcb_list_fonts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7467 } 7468 7469 int 7470 xcb_list_fonts_with_info_sizeof (const void *_buffer /**< */) 7471 { 7472 char *xcb_tmp = (char *)_buffer; 7473 const xcb_list_fonts_with_info_request_t *_aux = (xcb_list_fonts_with_info_request_t *)_buffer; 7474 unsigned int xcb_buffer_len = 0; 7475 unsigned int xcb_block_len = 0; 7476 unsigned int xcb_pad = 0; 7477 unsigned int xcb_align_to; 7478 7479 7480 xcb_block_len += sizeof(xcb_list_fonts_with_info_request_t); 7481 xcb_tmp += xcb_block_len; 7482 /* pattern */ 7483 xcb_block_len += _aux->pattern_len * sizeof(char); 7484 xcb_tmp += xcb_block_len; 7485 xcb_align_to = ALIGNOF(char); 7486 /* insert padding */ 7487 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7488 xcb_buffer_len += xcb_block_len + xcb_pad; 7489 if (0 != xcb_pad) { 7490 xcb_tmp += xcb_pad; 7491 xcb_pad = 0; 7492 } 7493 xcb_block_len = 0; 7494 7495 return xcb_buffer_len; 7496 } 7497 7498 7499 /***************************************************************************** 7500 ** 7501 ** xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info 7502 ** 7503 ** @param xcb_connection_t *c 7504 ** @param uint16_t max_names 7505 ** @param uint16_t pattern_len 7506 ** @param const char *pattern 7507 ** @returns xcb_list_fonts_with_info_cookie_t 7508 ** 7509 *****************************************************************************/ 7510 7511 xcb_list_fonts_with_info_cookie_t 7512 xcb_list_fonts_with_info (xcb_connection_t *c /**< */, 7513 uint16_t max_names /**< */, 7514 uint16_t pattern_len /**< */, 7515 const char *pattern /**< */) 7516 { 7517 static const xcb_protocol_request_t xcb_req = { 7518 /* count */ 4, 7519 /* ext */ 0, 7520 /* opcode */ XCB_LIST_FONTS_WITH_INFO, 7521 /* isvoid */ 0 7522 }; 7523 7524 struct iovec xcb_parts[6]; 7525 xcb_list_fonts_with_info_cookie_t xcb_ret; 7526 xcb_list_fonts_with_info_request_t xcb_out; 7527 7528 xcb_out.pad0 = 0; 7529 xcb_out.max_names = max_names; 7530 xcb_out.pattern_len = pattern_len; 7531 7532 xcb_parts[2].iov_base = (char *) &xcb_out; 7533 xcb_parts[2].iov_len = sizeof(xcb_out); 7534 xcb_parts[3].iov_base = 0; 7535 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7536 /* char pattern */ 7537 xcb_parts[4].iov_base = (char *) pattern; 7538 xcb_parts[4].iov_len = pattern_len * sizeof(char); 7539 xcb_parts[5].iov_base = 0; 7540 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7541 7542 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7543 return xcb_ret; 7544 } 7545 7546 7547 /***************************************************************************** 7548 ** 7549 ** xcb_list_fonts_with_info_cookie_t xcb_list_fonts_with_info_unchecked 7550 ** 7551 ** @param xcb_connection_t *c 7552 ** @param uint16_t max_names 7553 ** @param uint16_t pattern_len 7554 ** @param const char *pattern 7555 ** @returns xcb_list_fonts_with_info_cookie_t 7556 ** 7557 *****************************************************************************/ 7558 7559 xcb_list_fonts_with_info_cookie_t 7560 xcb_list_fonts_with_info_unchecked (xcb_connection_t *c /**< */, 7561 uint16_t max_names /**< */, 7562 uint16_t pattern_len /**< */, 7563 const char *pattern /**< */) 7564 { 7565 static const xcb_protocol_request_t xcb_req = { 7566 /* count */ 4, 7567 /* ext */ 0, 7568 /* opcode */ XCB_LIST_FONTS_WITH_INFO, 7569 /* isvoid */ 0 7570 }; 7571 7572 struct iovec xcb_parts[6]; 7573 xcb_list_fonts_with_info_cookie_t xcb_ret; 7574 xcb_list_fonts_with_info_request_t xcb_out; 7575 7576 xcb_out.pad0 = 0; 7577 xcb_out.max_names = max_names; 7578 xcb_out.pattern_len = pattern_len; 7579 7580 xcb_parts[2].iov_base = (char *) &xcb_out; 7581 xcb_parts[2].iov_len = sizeof(xcb_out); 7582 xcb_parts[3].iov_base = 0; 7583 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7584 /* char pattern */ 7585 xcb_parts[4].iov_base = (char *) pattern; 7586 xcb_parts[4].iov_len = pattern_len * sizeof(char); 7587 xcb_parts[5].iov_base = 0; 7588 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7589 7590 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7591 return xcb_ret; 7592 } 7593 7594 7595 /***************************************************************************** 7596 ** 7597 ** xcb_fontprop_t * xcb_list_fonts_with_info_properties 7598 ** 7599 ** @param const xcb_list_fonts_with_info_reply_t *R 7600 ** @returns xcb_fontprop_t * 7601 ** 7602 *****************************************************************************/ 7603 7604 xcb_fontprop_t * 7605 xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R /**< */) 7606 { 7607 return (xcb_fontprop_t *) (R + 1); 7608 } 7609 7610 7611 /***************************************************************************** 7612 ** 7613 ** int xcb_list_fonts_with_info_properties_length 7614 ** 7615 ** @param const xcb_list_fonts_with_info_reply_t *R 7616 ** @returns int 7617 ** 7618 *****************************************************************************/ 7619 7620 int 7621 xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R /**< */) 7622 { 7623 return R->properties_len; 7624 } 7625 7626 7627 /***************************************************************************** 7628 ** 7629 ** xcb_fontprop_iterator_t xcb_list_fonts_with_info_properties_iterator 7630 ** 7631 ** @param const xcb_list_fonts_with_info_reply_t *R 7632 ** @returns xcb_fontprop_iterator_t 7633 ** 7634 *****************************************************************************/ 7635 7636 xcb_fontprop_iterator_t 7637 xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R /**< */) 7638 { 7639 xcb_fontprop_iterator_t i; 7640 i.data = (xcb_fontprop_t *) (R + 1); 7641 i.rem = R->properties_len; 7642 i.index = (char *) i.data - (char *) R; 7643 return i; 7644 } 7645 7646 7647 /***************************************************************************** 7648 ** 7649 ** char * xcb_list_fonts_with_info_name 7650 ** 7651 ** @param const xcb_list_fonts_with_info_reply_t *R 7652 ** @returns char * 7653 ** 7654 *****************************************************************************/ 7655 7656 char * 7657 xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R /**< */) 7658 { 7659 xcb_generic_iterator_t prev = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R)); 7660 return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); 7661 } 7662 7663 7664 /***************************************************************************** 7665 ** 7666 ** int xcb_list_fonts_with_info_name_length 7667 ** 7668 ** @param const xcb_list_fonts_with_info_reply_t *R 7669 ** @returns int 7670 ** 7671 *****************************************************************************/ 7672 7673 int 7674 xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R /**< */) 7675 { 7676 return R->name_len; 7677 } 7678 7679 7680 /***************************************************************************** 7681 ** 7682 ** xcb_generic_iterator_t xcb_list_fonts_with_info_name_end 7683 ** 7684 ** @param const xcb_list_fonts_with_info_reply_t *R 7685 ** @returns xcb_generic_iterator_t 7686 ** 7687 *****************************************************************************/ 7688 7689 xcb_generic_iterator_t 7690 xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R /**< */) 7691 { 7692 xcb_generic_iterator_t i; 7693 xcb_generic_iterator_t child = xcb_fontprop_end(xcb_list_fonts_with_info_properties_iterator(R)); 7694 i.data = ((char *) child.data) + (R->name_len); 7695 i.rem = 0; 7696 i.index = (char *) i.data - (char *) R; 7697 return i; 7698 } 7699 7700 7701 /***************************************************************************** 7702 ** 7703 ** xcb_list_fonts_with_info_reply_t * xcb_list_fonts_with_info_reply 7704 ** 7705 ** @param xcb_connection_t *c 7706 ** @param xcb_list_fonts_with_info_cookie_t cookie 7707 ** @param xcb_generic_error_t **e 7708 ** @returns xcb_list_fonts_with_info_reply_t * 7709 ** 7710 *****************************************************************************/ 7711 7712 xcb_list_fonts_with_info_reply_t * 7713 xcb_list_fonts_with_info_reply (xcb_connection_t *c /**< */, 7714 xcb_list_fonts_with_info_cookie_t cookie /**< */, 7715 xcb_generic_error_t **e /**< */) 7716 { 7717 return (xcb_list_fonts_with_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 7718 } 7719 7720 int 7721 xcb_set_font_path_sizeof (const void *_buffer /**< */) 7722 { 7723 char *xcb_tmp = (char *)_buffer; 7724 const xcb_set_font_path_request_t *_aux = (xcb_set_font_path_request_t *)_buffer; 7725 unsigned int xcb_buffer_len = 0; 7726 unsigned int xcb_block_len = 0; 7727 unsigned int xcb_pad = 0; 7728 unsigned int xcb_align_to; 7729 7730 unsigned int i; 7731 unsigned int xcb_tmp_len; 7732 7733 xcb_block_len += sizeof(xcb_set_font_path_request_t); 7734 xcb_tmp += xcb_block_len; 7735 /* font */ 7736 for(i=0; i<_aux->font_qty; i++) { 7737 xcb_tmp_len = xcb_str_sizeof(xcb_tmp); 7738 xcb_block_len += xcb_tmp_len; 7739 xcb_tmp += xcb_tmp_len; 7740 } 7741 xcb_align_to = ALIGNOF(xcb_str_t); 7742 /* insert padding */ 7743 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7744 xcb_buffer_len += xcb_block_len + xcb_pad; 7745 if (0 != xcb_pad) { 7746 xcb_tmp += xcb_pad; 7747 xcb_pad = 0; 7748 } 7749 xcb_block_len = 0; 7750 7751 return xcb_buffer_len; 7752 } 7753 7754 7755 /***************************************************************************** 7756 ** 7757 ** xcb_void_cookie_t xcb_set_font_path_checked 7758 ** 7759 ** @param xcb_connection_t *c 7760 ** @param uint16_t font_qty 7761 ** @param const xcb_str_t *font 7762 ** @returns xcb_void_cookie_t 7763 ** 7764 *****************************************************************************/ 7765 7766 xcb_void_cookie_t 7767 xcb_set_font_path_checked (xcb_connection_t *c /**< */, 7768 uint16_t font_qty /**< */, 7769 const xcb_str_t *font /**< */) 7770 { 7771 static const xcb_protocol_request_t xcb_req = { 7772 /* count */ 4, 7773 /* ext */ 0, 7774 /* opcode */ XCB_SET_FONT_PATH, 7775 /* isvoid */ 1 7776 }; 7777 7778 struct iovec xcb_parts[6]; 7779 xcb_void_cookie_t xcb_ret; 7780 xcb_set_font_path_request_t xcb_out; 7781 unsigned int i; 7782 unsigned int xcb_tmp_len; 7783 char *xcb_tmp; 7784 7785 xcb_out.pad0 = 0; 7786 xcb_out.font_qty = font_qty; 7787 memset(xcb_out.pad1, 0, 2); 7788 7789 xcb_parts[2].iov_base = (char *) &xcb_out; 7790 xcb_parts[2].iov_len = sizeof(xcb_out); 7791 xcb_parts[3].iov_base = 0; 7792 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7793 /* xcb_str_t font */ 7794 xcb_parts[4].iov_base = (char *) font; 7795 xcb_parts[4].iov_len = 0; 7796 xcb_tmp = (char *)font; 7797 for(i=0; i<font_qty; i++) { 7798 xcb_tmp_len = xcb_str_sizeof(xcb_tmp); 7799 xcb_parts[4].iov_len += xcb_tmp_len; 7800 xcb_tmp += xcb_tmp_len; 7801 } 7802 xcb_parts[5].iov_base = 0; 7803 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7804 7805 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7806 return xcb_ret; 7807 } 7808 7809 7810 /***************************************************************************** 7811 ** 7812 ** xcb_void_cookie_t xcb_set_font_path 7813 ** 7814 ** @param xcb_connection_t *c 7815 ** @param uint16_t font_qty 7816 ** @param const xcb_str_t *font 7817 ** @returns xcb_void_cookie_t 7818 ** 7819 *****************************************************************************/ 7820 7821 xcb_void_cookie_t 7822 xcb_set_font_path (xcb_connection_t *c /**< */, 7823 uint16_t font_qty /**< */, 7824 const xcb_str_t *font /**< */) 7825 { 7826 static const xcb_protocol_request_t xcb_req = { 7827 /* count */ 4, 7828 /* ext */ 0, 7829 /* opcode */ XCB_SET_FONT_PATH, 7830 /* isvoid */ 1 7831 }; 7832 7833 struct iovec xcb_parts[6]; 7834 xcb_void_cookie_t xcb_ret; 7835 xcb_set_font_path_request_t xcb_out; 7836 unsigned int i; 7837 unsigned int xcb_tmp_len; 7838 char *xcb_tmp; 7839 7840 xcb_out.pad0 = 0; 7841 xcb_out.font_qty = font_qty; 7842 memset(xcb_out.pad1, 0, 2); 7843 7844 xcb_parts[2].iov_base = (char *) &xcb_out; 7845 xcb_parts[2].iov_len = sizeof(xcb_out); 7846 xcb_parts[3].iov_base = 0; 7847 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7848 /* xcb_str_t font */ 7849 xcb_parts[4].iov_base = (char *) font; 7850 xcb_parts[4].iov_len = 0; 7851 xcb_tmp = (char *)font; 7852 for(i=0; i<font_qty; i++) { 7853 xcb_tmp_len = xcb_str_sizeof(xcb_tmp); 7854 xcb_parts[4].iov_len += xcb_tmp_len; 7855 xcb_tmp += xcb_tmp_len; 7856 } 7857 xcb_parts[5].iov_base = 0; 7858 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 7859 7860 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7861 return xcb_ret; 7862 } 7863 7864 int 7865 xcb_get_font_path_sizeof (const void *_buffer /**< */) 7866 { 7867 char *xcb_tmp = (char *)_buffer; 7868 const xcb_get_font_path_reply_t *_aux = (xcb_get_font_path_reply_t *)_buffer; 7869 unsigned int xcb_buffer_len = 0; 7870 unsigned int xcb_block_len = 0; 7871 unsigned int xcb_pad = 0; 7872 unsigned int xcb_align_to; 7873 7874 unsigned int i; 7875 unsigned int xcb_tmp_len; 7876 7877 xcb_block_len += sizeof(xcb_get_font_path_reply_t); 7878 xcb_tmp += xcb_block_len; 7879 /* path */ 7880 for(i=0; i<_aux->path_len; i++) { 7881 xcb_tmp_len = xcb_str_sizeof(xcb_tmp); 7882 xcb_block_len += xcb_tmp_len; 7883 xcb_tmp += xcb_tmp_len; 7884 } 7885 xcb_align_to = ALIGNOF(xcb_str_t); 7886 /* insert padding */ 7887 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 7888 xcb_buffer_len += xcb_block_len + xcb_pad; 7889 if (0 != xcb_pad) { 7890 xcb_tmp += xcb_pad; 7891 xcb_pad = 0; 7892 } 7893 xcb_block_len = 0; 7894 7895 return xcb_buffer_len; 7896 } 7897 7898 7899 /***************************************************************************** 7900 ** 7901 ** xcb_get_font_path_cookie_t xcb_get_font_path 7902 ** 7903 ** @param xcb_connection_t *c 7904 ** @returns xcb_get_font_path_cookie_t 7905 ** 7906 *****************************************************************************/ 7907 7908 xcb_get_font_path_cookie_t 7909 xcb_get_font_path (xcb_connection_t *c /**< */) 7910 { 7911 static const xcb_protocol_request_t xcb_req = { 7912 /* count */ 2, 7913 /* ext */ 0, 7914 /* opcode */ XCB_GET_FONT_PATH, 7915 /* isvoid */ 0 7916 }; 7917 7918 struct iovec xcb_parts[4]; 7919 xcb_get_font_path_cookie_t xcb_ret; 7920 xcb_get_font_path_request_t xcb_out; 7921 7922 xcb_out.pad0 = 0; 7923 7924 xcb_parts[2].iov_base = (char *) &xcb_out; 7925 xcb_parts[2].iov_len = sizeof(xcb_out); 7926 xcb_parts[3].iov_base = 0; 7927 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7928 7929 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 7930 return xcb_ret; 7931 } 7932 7933 7934 /***************************************************************************** 7935 ** 7936 ** xcb_get_font_path_cookie_t xcb_get_font_path_unchecked 7937 ** 7938 ** @param xcb_connection_t *c 7939 ** @returns xcb_get_font_path_cookie_t 7940 ** 7941 *****************************************************************************/ 7942 7943 xcb_get_font_path_cookie_t 7944 xcb_get_font_path_unchecked (xcb_connection_t *c /**< */) 7945 { 7946 static const xcb_protocol_request_t xcb_req = { 7947 /* count */ 2, 7948 /* ext */ 0, 7949 /* opcode */ XCB_GET_FONT_PATH, 7950 /* isvoid */ 0 7951 }; 7952 7953 struct iovec xcb_parts[4]; 7954 xcb_get_font_path_cookie_t xcb_ret; 7955 xcb_get_font_path_request_t xcb_out; 7956 7957 xcb_out.pad0 = 0; 7958 7959 xcb_parts[2].iov_base = (char *) &xcb_out; 7960 xcb_parts[2].iov_len = sizeof(xcb_out); 7961 xcb_parts[3].iov_base = 0; 7962 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 7963 7964 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 7965 return xcb_ret; 7966 } 7967 7968 7969 /***************************************************************************** 7970 ** 7971 ** int xcb_get_font_path_path_length 7972 ** 7973 ** @param const xcb_get_font_path_reply_t *R 7974 ** @returns int 7975 ** 7976 *****************************************************************************/ 7977 7978 int 7979 xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R /**< */) 7980 { 7981 return R->path_len; 7982 } 7983 7984 7985 /***************************************************************************** 7986 ** 7987 ** xcb_str_iterator_t xcb_get_font_path_path_iterator 7988 ** 7989 ** @param const xcb_get_font_path_reply_t *R 7990 ** @returns xcb_str_iterator_t 7991 ** 7992 *****************************************************************************/ 7993 7994 xcb_str_iterator_t 7995 xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R /**< */) 7996 { 7997 xcb_str_iterator_t i; 7998 i.data = (xcb_str_t *) (R + 1); 7999 i.rem = R->path_len; 8000 i.index = (char *) i.data - (char *) R; 8001 return i; 8002 } 8003 8004 8005 /***************************************************************************** 8006 ** 8007 ** xcb_get_font_path_reply_t * xcb_get_font_path_reply 8008 ** 8009 ** @param xcb_connection_t *c 8010 ** @param xcb_get_font_path_cookie_t cookie 8011 ** @param xcb_generic_error_t **e 8012 ** @returns xcb_get_font_path_reply_t * 8013 ** 8014 *****************************************************************************/ 8015 8016 xcb_get_font_path_reply_t * 8017 xcb_get_font_path_reply (xcb_connection_t *c /**< */, 8018 xcb_get_font_path_cookie_t cookie /**< */, 8019 xcb_generic_error_t **e /**< */) 8020 { 8021 return (xcb_get_font_path_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 8022 } 8023 8024 8025 /***************************************************************************** 8026 ** 8027 ** xcb_void_cookie_t xcb_create_pixmap_checked 8028 ** 8029 ** @param xcb_connection_t *c 8030 ** @param uint8_t depth 8031 ** @param xcb_pixmap_t pid 8032 ** @param xcb_drawable_t drawable 8033 ** @param uint16_t width 8034 ** @param uint16_t height 8035 ** @returns xcb_void_cookie_t 8036 ** 8037 *****************************************************************************/ 8038 8039 xcb_void_cookie_t 8040 xcb_create_pixmap_checked (xcb_connection_t *c /**< */, 8041 uint8_t depth /**< */, 8042 xcb_pixmap_t pid /**< */, 8043 xcb_drawable_t drawable /**< */, 8044 uint16_t width /**< */, 8045 uint16_t height /**< */) 8046 { 8047 static const xcb_protocol_request_t xcb_req = { 8048 /* count */ 2, 8049 /* ext */ 0, 8050 /* opcode */ XCB_CREATE_PIXMAP, 8051 /* isvoid */ 1 8052 }; 8053 8054 struct iovec xcb_parts[4]; 8055 xcb_void_cookie_t xcb_ret; 8056 xcb_create_pixmap_request_t xcb_out; 8057 8058 xcb_out.depth = depth; 8059 xcb_out.pid = pid; 8060 xcb_out.drawable = drawable; 8061 xcb_out.width = width; 8062 xcb_out.height = height; 8063 8064 xcb_parts[2].iov_base = (char *) &xcb_out; 8065 xcb_parts[2].iov_len = sizeof(xcb_out); 8066 xcb_parts[3].iov_base = 0; 8067 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8068 8069 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8070 return xcb_ret; 8071 } 8072 8073 8074 /***************************************************************************** 8075 ** 8076 ** xcb_void_cookie_t xcb_create_pixmap 8077 ** 8078 ** @param xcb_connection_t *c 8079 ** @param uint8_t depth 8080 ** @param xcb_pixmap_t pid 8081 ** @param xcb_drawable_t drawable 8082 ** @param uint16_t width 8083 ** @param uint16_t height 8084 ** @returns xcb_void_cookie_t 8085 ** 8086 *****************************************************************************/ 8087 8088 xcb_void_cookie_t 8089 xcb_create_pixmap (xcb_connection_t *c /**< */, 8090 uint8_t depth /**< */, 8091 xcb_pixmap_t pid /**< */, 8092 xcb_drawable_t drawable /**< */, 8093 uint16_t width /**< */, 8094 uint16_t height /**< */) 8095 { 8096 static const xcb_protocol_request_t xcb_req = { 8097 /* count */ 2, 8098 /* ext */ 0, 8099 /* opcode */ XCB_CREATE_PIXMAP, 8100 /* isvoid */ 1 8101 }; 8102 8103 struct iovec xcb_parts[4]; 8104 xcb_void_cookie_t xcb_ret; 8105 xcb_create_pixmap_request_t xcb_out; 8106 8107 xcb_out.depth = depth; 8108 xcb_out.pid = pid; 8109 xcb_out.drawable = drawable; 8110 xcb_out.width = width; 8111 xcb_out.height = height; 8112 8113 xcb_parts[2].iov_base = (char *) &xcb_out; 8114 xcb_parts[2].iov_len = sizeof(xcb_out); 8115 xcb_parts[3].iov_base = 0; 8116 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8117 8118 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8119 return xcb_ret; 8120 } 8121 8122 8123 /***************************************************************************** 8124 ** 8125 ** xcb_void_cookie_t xcb_free_pixmap_checked 8126 ** 8127 ** @param xcb_connection_t *c 8128 ** @param xcb_pixmap_t pixmap 8129 ** @returns xcb_void_cookie_t 8130 ** 8131 *****************************************************************************/ 8132 8133 xcb_void_cookie_t 8134 xcb_free_pixmap_checked (xcb_connection_t *c /**< */, 8135 xcb_pixmap_t pixmap /**< */) 8136 { 8137 static const xcb_protocol_request_t xcb_req = { 8138 /* count */ 2, 8139 /* ext */ 0, 8140 /* opcode */ XCB_FREE_PIXMAP, 8141 /* isvoid */ 1 8142 }; 8143 8144 struct iovec xcb_parts[4]; 8145 xcb_void_cookie_t xcb_ret; 8146 xcb_free_pixmap_request_t xcb_out; 8147 8148 xcb_out.pad0 = 0; 8149 xcb_out.pixmap = pixmap; 8150 8151 xcb_parts[2].iov_base = (char *) &xcb_out; 8152 xcb_parts[2].iov_len = sizeof(xcb_out); 8153 xcb_parts[3].iov_base = 0; 8154 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8155 8156 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8157 return xcb_ret; 8158 } 8159 8160 8161 /***************************************************************************** 8162 ** 8163 ** xcb_void_cookie_t xcb_free_pixmap 8164 ** 8165 ** @param xcb_connection_t *c 8166 ** @param xcb_pixmap_t pixmap 8167 ** @returns xcb_void_cookie_t 8168 ** 8169 *****************************************************************************/ 8170 8171 xcb_void_cookie_t 8172 xcb_free_pixmap (xcb_connection_t *c /**< */, 8173 xcb_pixmap_t pixmap /**< */) 8174 { 8175 static const xcb_protocol_request_t xcb_req = { 8176 /* count */ 2, 8177 /* ext */ 0, 8178 /* opcode */ XCB_FREE_PIXMAP, 8179 /* isvoid */ 1 8180 }; 8181 8182 struct iovec xcb_parts[4]; 8183 xcb_void_cookie_t xcb_ret; 8184 xcb_free_pixmap_request_t xcb_out; 8185 8186 xcb_out.pad0 = 0; 8187 xcb_out.pixmap = pixmap; 8188 8189 xcb_parts[2].iov_base = (char *) &xcb_out; 8190 xcb_parts[2].iov_len = sizeof(xcb_out); 8191 xcb_parts[3].iov_base = 0; 8192 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8193 8194 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8195 return xcb_ret; 8196 } 8197 8198 int 8199 xcb_create_gc_sizeof (const void *_buffer /**< */) 8200 { 8201 char *xcb_tmp = (char *)_buffer; 8202 const xcb_create_gc_request_t *_aux = (xcb_create_gc_request_t *)_buffer; 8203 unsigned int xcb_buffer_len = 0; 8204 unsigned int xcb_block_len = 0; 8205 unsigned int xcb_pad = 0; 8206 unsigned int xcb_align_to; 8207 8208 8209 xcb_block_len += sizeof(xcb_create_gc_request_t); 8210 xcb_tmp += xcb_block_len; 8211 /* value_list */ 8212 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 8213 xcb_tmp += xcb_block_len; 8214 xcb_align_to = ALIGNOF(uint32_t); 8215 /* insert padding */ 8216 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8217 xcb_buffer_len += xcb_block_len + xcb_pad; 8218 if (0 != xcb_pad) { 8219 xcb_tmp += xcb_pad; 8220 xcb_pad = 0; 8221 } 8222 xcb_block_len = 0; 8223 8224 return xcb_buffer_len; 8225 } 8226 8227 8228 /***************************************************************************** 8229 ** 8230 ** xcb_void_cookie_t xcb_create_gc_checked 8231 ** 8232 ** @param xcb_connection_t *c 8233 ** @param xcb_gcontext_t cid 8234 ** @param xcb_drawable_t drawable 8235 ** @param uint32_t value_mask 8236 ** @param const uint32_t *value_list 8237 ** @returns xcb_void_cookie_t 8238 ** 8239 *****************************************************************************/ 8240 8241 xcb_void_cookie_t 8242 xcb_create_gc_checked (xcb_connection_t *c /**< */, 8243 xcb_gcontext_t cid /**< */, 8244 xcb_drawable_t drawable /**< */, 8245 uint32_t value_mask /**< */, 8246 const uint32_t *value_list /**< */) 8247 { 8248 static const xcb_protocol_request_t xcb_req = { 8249 /* count */ 4, 8250 /* ext */ 0, 8251 /* opcode */ XCB_CREATE_GC, 8252 /* isvoid */ 1 8253 }; 8254 8255 struct iovec xcb_parts[6]; 8256 xcb_void_cookie_t xcb_ret; 8257 xcb_create_gc_request_t xcb_out; 8258 8259 xcb_out.pad0 = 0; 8260 xcb_out.cid = cid; 8261 xcb_out.drawable = drawable; 8262 xcb_out.value_mask = value_mask; 8263 8264 xcb_parts[2].iov_base = (char *) &xcb_out; 8265 xcb_parts[2].iov_len = sizeof(xcb_out); 8266 xcb_parts[3].iov_base = 0; 8267 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8268 /* uint32_t value_list */ 8269 xcb_parts[4].iov_base = (char *) value_list; 8270 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 8271 xcb_parts[5].iov_base = 0; 8272 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8273 8274 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8275 return xcb_ret; 8276 } 8277 8278 8279 /***************************************************************************** 8280 ** 8281 ** xcb_void_cookie_t xcb_create_gc 8282 ** 8283 ** @param xcb_connection_t *c 8284 ** @param xcb_gcontext_t cid 8285 ** @param xcb_drawable_t drawable 8286 ** @param uint32_t value_mask 8287 ** @param const uint32_t *value_list 8288 ** @returns xcb_void_cookie_t 8289 ** 8290 *****************************************************************************/ 8291 8292 xcb_void_cookie_t 8293 xcb_create_gc (xcb_connection_t *c /**< */, 8294 xcb_gcontext_t cid /**< */, 8295 xcb_drawable_t drawable /**< */, 8296 uint32_t value_mask /**< */, 8297 const uint32_t *value_list /**< */) 8298 { 8299 static const xcb_protocol_request_t xcb_req = { 8300 /* count */ 4, 8301 /* ext */ 0, 8302 /* opcode */ XCB_CREATE_GC, 8303 /* isvoid */ 1 8304 }; 8305 8306 struct iovec xcb_parts[6]; 8307 xcb_void_cookie_t xcb_ret; 8308 xcb_create_gc_request_t xcb_out; 8309 8310 xcb_out.pad0 = 0; 8311 xcb_out.cid = cid; 8312 xcb_out.drawable = drawable; 8313 xcb_out.value_mask = value_mask; 8314 8315 xcb_parts[2].iov_base = (char *) &xcb_out; 8316 xcb_parts[2].iov_len = sizeof(xcb_out); 8317 xcb_parts[3].iov_base = 0; 8318 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8319 /* uint32_t value_list */ 8320 xcb_parts[4].iov_base = (char *) value_list; 8321 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 8322 xcb_parts[5].iov_base = 0; 8323 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8324 8325 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8326 return xcb_ret; 8327 } 8328 8329 int 8330 xcb_change_gc_sizeof (const void *_buffer /**< */) 8331 { 8332 char *xcb_tmp = (char *)_buffer; 8333 const xcb_change_gc_request_t *_aux = (xcb_change_gc_request_t *)_buffer; 8334 unsigned int xcb_buffer_len = 0; 8335 unsigned int xcb_block_len = 0; 8336 unsigned int xcb_pad = 0; 8337 unsigned int xcb_align_to; 8338 8339 8340 xcb_block_len += sizeof(xcb_change_gc_request_t); 8341 xcb_tmp += xcb_block_len; 8342 /* value_list */ 8343 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 8344 xcb_tmp += xcb_block_len; 8345 xcb_align_to = ALIGNOF(uint32_t); 8346 /* insert padding */ 8347 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8348 xcb_buffer_len += xcb_block_len + xcb_pad; 8349 if (0 != xcb_pad) { 8350 xcb_tmp += xcb_pad; 8351 xcb_pad = 0; 8352 } 8353 xcb_block_len = 0; 8354 8355 return xcb_buffer_len; 8356 } 8357 8358 8359 /***************************************************************************** 8360 ** 8361 ** xcb_void_cookie_t xcb_change_gc_checked 8362 ** 8363 ** @param xcb_connection_t *c 8364 ** @param xcb_gcontext_t gc 8365 ** @param uint32_t value_mask 8366 ** @param const uint32_t *value_list 8367 ** @returns xcb_void_cookie_t 8368 ** 8369 *****************************************************************************/ 8370 8371 xcb_void_cookie_t 8372 xcb_change_gc_checked (xcb_connection_t *c /**< */, 8373 xcb_gcontext_t gc /**< */, 8374 uint32_t value_mask /**< */, 8375 const uint32_t *value_list /**< */) 8376 { 8377 static const xcb_protocol_request_t xcb_req = { 8378 /* count */ 4, 8379 /* ext */ 0, 8380 /* opcode */ XCB_CHANGE_GC, 8381 /* isvoid */ 1 8382 }; 8383 8384 struct iovec xcb_parts[6]; 8385 xcb_void_cookie_t xcb_ret; 8386 xcb_change_gc_request_t xcb_out; 8387 8388 xcb_out.pad0 = 0; 8389 xcb_out.gc = gc; 8390 xcb_out.value_mask = value_mask; 8391 8392 xcb_parts[2].iov_base = (char *) &xcb_out; 8393 xcb_parts[2].iov_len = sizeof(xcb_out); 8394 xcb_parts[3].iov_base = 0; 8395 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8396 /* uint32_t value_list */ 8397 xcb_parts[4].iov_base = (char *) value_list; 8398 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 8399 xcb_parts[5].iov_base = 0; 8400 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8401 8402 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8403 return xcb_ret; 8404 } 8405 8406 8407 /***************************************************************************** 8408 ** 8409 ** xcb_void_cookie_t xcb_change_gc 8410 ** 8411 ** @param xcb_connection_t *c 8412 ** @param xcb_gcontext_t gc 8413 ** @param uint32_t value_mask 8414 ** @param const uint32_t *value_list 8415 ** @returns xcb_void_cookie_t 8416 ** 8417 *****************************************************************************/ 8418 8419 xcb_void_cookie_t 8420 xcb_change_gc (xcb_connection_t *c /**< */, 8421 xcb_gcontext_t gc /**< */, 8422 uint32_t value_mask /**< */, 8423 const uint32_t *value_list /**< */) 8424 { 8425 static const xcb_protocol_request_t xcb_req = { 8426 /* count */ 4, 8427 /* ext */ 0, 8428 /* opcode */ XCB_CHANGE_GC, 8429 /* isvoid */ 1 8430 }; 8431 8432 struct iovec xcb_parts[6]; 8433 xcb_void_cookie_t xcb_ret; 8434 xcb_change_gc_request_t xcb_out; 8435 8436 xcb_out.pad0 = 0; 8437 xcb_out.gc = gc; 8438 xcb_out.value_mask = value_mask; 8439 8440 xcb_parts[2].iov_base = (char *) &xcb_out; 8441 xcb_parts[2].iov_len = sizeof(xcb_out); 8442 xcb_parts[3].iov_base = 0; 8443 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8444 /* uint32_t value_list */ 8445 xcb_parts[4].iov_base = (char *) value_list; 8446 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 8447 xcb_parts[5].iov_base = 0; 8448 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8449 8450 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8451 return xcb_ret; 8452 } 8453 8454 8455 /***************************************************************************** 8456 ** 8457 ** xcb_void_cookie_t xcb_copy_gc_checked 8458 ** 8459 ** @param xcb_connection_t *c 8460 ** @param xcb_gcontext_t src_gc 8461 ** @param xcb_gcontext_t dst_gc 8462 ** @param uint32_t value_mask 8463 ** @returns xcb_void_cookie_t 8464 ** 8465 *****************************************************************************/ 8466 8467 xcb_void_cookie_t 8468 xcb_copy_gc_checked (xcb_connection_t *c /**< */, 8469 xcb_gcontext_t src_gc /**< */, 8470 xcb_gcontext_t dst_gc /**< */, 8471 uint32_t value_mask /**< */) 8472 { 8473 static const xcb_protocol_request_t xcb_req = { 8474 /* count */ 2, 8475 /* ext */ 0, 8476 /* opcode */ XCB_COPY_GC, 8477 /* isvoid */ 1 8478 }; 8479 8480 struct iovec xcb_parts[4]; 8481 xcb_void_cookie_t xcb_ret; 8482 xcb_copy_gc_request_t xcb_out; 8483 8484 xcb_out.pad0 = 0; 8485 xcb_out.src_gc = src_gc; 8486 xcb_out.dst_gc = dst_gc; 8487 xcb_out.value_mask = value_mask; 8488 8489 xcb_parts[2].iov_base = (char *) &xcb_out; 8490 xcb_parts[2].iov_len = sizeof(xcb_out); 8491 xcb_parts[3].iov_base = 0; 8492 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8493 8494 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8495 return xcb_ret; 8496 } 8497 8498 8499 /***************************************************************************** 8500 ** 8501 ** xcb_void_cookie_t xcb_copy_gc 8502 ** 8503 ** @param xcb_connection_t *c 8504 ** @param xcb_gcontext_t src_gc 8505 ** @param xcb_gcontext_t dst_gc 8506 ** @param uint32_t value_mask 8507 ** @returns xcb_void_cookie_t 8508 ** 8509 *****************************************************************************/ 8510 8511 xcb_void_cookie_t 8512 xcb_copy_gc (xcb_connection_t *c /**< */, 8513 xcb_gcontext_t src_gc /**< */, 8514 xcb_gcontext_t dst_gc /**< */, 8515 uint32_t value_mask /**< */) 8516 { 8517 static const xcb_protocol_request_t xcb_req = { 8518 /* count */ 2, 8519 /* ext */ 0, 8520 /* opcode */ XCB_COPY_GC, 8521 /* isvoid */ 1 8522 }; 8523 8524 struct iovec xcb_parts[4]; 8525 xcb_void_cookie_t xcb_ret; 8526 xcb_copy_gc_request_t xcb_out; 8527 8528 xcb_out.pad0 = 0; 8529 xcb_out.src_gc = src_gc; 8530 xcb_out.dst_gc = dst_gc; 8531 xcb_out.value_mask = value_mask; 8532 8533 xcb_parts[2].iov_base = (char *) &xcb_out; 8534 xcb_parts[2].iov_len = sizeof(xcb_out); 8535 xcb_parts[3].iov_base = 0; 8536 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8537 8538 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8539 return xcb_ret; 8540 } 8541 8542 int 8543 xcb_set_dashes_sizeof (const void *_buffer /**< */) 8544 { 8545 char *xcb_tmp = (char *)_buffer; 8546 const xcb_set_dashes_request_t *_aux = (xcb_set_dashes_request_t *)_buffer; 8547 unsigned int xcb_buffer_len = 0; 8548 unsigned int xcb_block_len = 0; 8549 unsigned int xcb_pad = 0; 8550 unsigned int xcb_align_to; 8551 8552 8553 xcb_block_len += sizeof(xcb_set_dashes_request_t); 8554 xcb_tmp += xcb_block_len; 8555 /* dashes */ 8556 xcb_block_len += _aux->dashes_len * sizeof(uint8_t); 8557 xcb_tmp += xcb_block_len; 8558 xcb_align_to = ALIGNOF(uint8_t); 8559 /* insert padding */ 8560 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8561 xcb_buffer_len += xcb_block_len + xcb_pad; 8562 if (0 != xcb_pad) { 8563 xcb_tmp += xcb_pad; 8564 xcb_pad = 0; 8565 } 8566 xcb_block_len = 0; 8567 8568 return xcb_buffer_len; 8569 } 8570 8571 8572 /***************************************************************************** 8573 ** 8574 ** xcb_void_cookie_t xcb_set_dashes_checked 8575 ** 8576 ** @param xcb_connection_t *c 8577 ** @param xcb_gcontext_t gc 8578 ** @param uint16_t dash_offset 8579 ** @param uint16_t dashes_len 8580 ** @param const uint8_t *dashes 8581 ** @returns xcb_void_cookie_t 8582 ** 8583 *****************************************************************************/ 8584 8585 xcb_void_cookie_t 8586 xcb_set_dashes_checked (xcb_connection_t *c /**< */, 8587 xcb_gcontext_t gc /**< */, 8588 uint16_t dash_offset /**< */, 8589 uint16_t dashes_len /**< */, 8590 const uint8_t *dashes /**< */) 8591 { 8592 static const xcb_protocol_request_t xcb_req = { 8593 /* count */ 4, 8594 /* ext */ 0, 8595 /* opcode */ XCB_SET_DASHES, 8596 /* isvoid */ 1 8597 }; 8598 8599 struct iovec xcb_parts[6]; 8600 xcb_void_cookie_t xcb_ret; 8601 xcb_set_dashes_request_t xcb_out; 8602 8603 xcb_out.pad0 = 0; 8604 xcb_out.gc = gc; 8605 xcb_out.dash_offset = dash_offset; 8606 xcb_out.dashes_len = dashes_len; 8607 8608 xcb_parts[2].iov_base = (char *) &xcb_out; 8609 xcb_parts[2].iov_len = sizeof(xcb_out); 8610 xcb_parts[3].iov_base = 0; 8611 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8612 /* uint8_t dashes */ 8613 xcb_parts[4].iov_base = (char *) dashes; 8614 xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t); 8615 xcb_parts[5].iov_base = 0; 8616 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8617 8618 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8619 return xcb_ret; 8620 } 8621 8622 8623 /***************************************************************************** 8624 ** 8625 ** xcb_void_cookie_t xcb_set_dashes 8626 ** 8627 ** @param xcb_connection_t *c 8628 ** @param xcb_gcontext_t gc 8629 ** @param uint16_t dash_offset 8630 ** @param uint16_t dashes_len 8631 ** @param const uint8_t *dashes 8632 ** @returns xcb_void_cookie_t 8633 ** 8634 *****************************************************************************/ 8635 8636 xcb_void_cookie_t 8637 xcb_set_dashes (xcb_connection_t *c /**< */, 8638 xcb_gcontext_t gc /**< */, 8639 uint16_t dash_offset /**< */, 8640 uint16_t dashes_len /**< */, 8641 const uint8_t *dashes /**< */) 8642 { 8643 static const xcb_protocol_request_t xcb_req = { 8644 /* count */ 4, 8645 /* ext */ 0, 8646 /* opcode */ XCB_SET_DASHES, 8647 /* isvoid */ 1 8648 }; 8649 8650 struct iovec xcb_parts[6]; 8651 xcb_void_cookie_t xcb_ret; 8652 xcb_set_dashes_request_t xcb_out; 8653 8654 xcb_out.pad0 = 0; 8655 xcb_out.gc = gc; 8656 xcb_out.dash_offset = dash_offset; 8657 xcb_out.dashes_len = dashes_len; 8658 8659 xcb_parts[2].iov_base = (char *) &xcb_out; 8660 xcb_parts[2].iov_len = sizeof(xcb_out); 8661 xcb_parts[3].iov_base = 0; 8662 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8663 /* uint8_t dashes */ 8664 xcb_parts[4].iov_base = (char *) dashes; 8665 xcb_parts[4].iov_len = dashes_len * sizeof(uint8_t); 8666 xcb_parts[5].iov_base = 0; 8667 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8668 8669 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8670 return xcb_ret; 8671 } 8672 8673 int 8674 xcb_set_clip_rectangles_sizeof (const void *_buffer /**< */, 8675 uint32_t rectangles_len /**< */) 8676 { 8677 char *xcb_tmp = (char *)_buffer; 8678 unsigned int xcb_buffer_len = 0; 8679 unsigned int xcb_block_len = 0; 8680 unsigned int xcb_pad = 0; 8681 unsigned int xcb_align_to; 8682 8683 8684 xcb_block_len += sizeof(xcb_set_clip_rectangles_request_t); 8685 xcb_tmp += xcb_block_len; 8686 /* rectangles */ 8687 xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); 8688 xcb_tmp += xcb_block_len; 8689 xcb_align_to = ALIGNOF(xcb_rectangle_t); 8690 /* insert padding */ 8691 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 8692 xcb_buffer_len += xcb_block_len + xcb_pad; 8693 if (0 != xcb_pad) { 8694 xcb_tmp += xcb_pad; 8695 xcb_pad = 0; 8696 } 8697 xcb_block_len = 0; 8698 8699 return xcb_buffer_len; 8700 } 8701 8702 8703 /***************************************************************************** 8704 ** 8705 ** xcb_void_cookie_t xcb_set_clip_rectangles_checked 8706 ** 8707 ** @param xcb_connection_t *c 8708 ** @param uint8_t ordering 8709 ** @param xcb_gcontext_t gc 8710 ** @param int16_t clip_x_origin 8711 ** @param int16_t clip_y_origin 8712 ** @param uint32_t rectangles_len 8713 ** @param const xcb_rectangle_t *rectangles 8714 ** @returns xcb_void_cookie_t 8715 ** 8716 *****************************************************************************/ 8717 8718 xcb_void_cookie_t 8719 xcb_set_clip_rectangles_checked (xcb_connection_t *c /**< */, 8720 uint8_t ordering /**< */, 8721 xcb_gcontext_t gc /**< */, 8722 int16_t clip_x_origin /**< */, 8723 int16_t clip_y_origin /**< */, 8724 uint32_t rectangles_len /**< */, 8725 const xcb_rectangle_t *rectangles /**< */) 8726 { 8727 static const xcb_protocol_request_t xcb_req = { 8728 /* count */ 4, 8729 /* ext */ 0, 8730 /* opcode */ XCB_SET_CLIP_RECTANGLES, 8731 /* isvoid */ 1 8732 }; 8733 8734 struct iovec xcb_parts[6]; 8735 xcb_void_cookie_t xcb_ret; 8736 xcb_set_clip_rectangles_request_t xcb_out; 8737 8738 xcb_out.ordering = ordering; 8739 xcb_out.gc = gc; 8740 xcb_out.clip_x_origin = clip_x_origin; 8741 xcb_out.clip_y_origin = clip_y_origin; 8742 8743 xcb_parts[2].iov_base = (char *) &xcb_out; 8744 xcb_parts[2].iov_len = sizeof(xcb_out); 8745 xcb_parts[3].iov_base = 0; 8746 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8747 /* xcb_rectangle_t rectangles */ 8748 xcb_parts[4].iov_base = (char *) rectangles; 8749 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 8750 xcb_parts[5].iov_base = 0; 8751 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8752 8753 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8754 return xcb_ret; 8755 } 8756 8757 8758 /***************************************************************************** 8759 ** 8760 ** xcb_void_cookie_t xcb_set_clip_rectangles 8761 ** 8762 ** @param xcb_connection_t *c 8763 ** @param uint8_t ordering 8764 ** @param xcb_gcontext_t gc 8765 ** @param int16_t clip_x_origin 8766 ** @param int16_t clip_y_origin 8767 ** @param uint32_t rectangles_len 8768 ** @param const xcb_rectangle_t *rectangles 8769 ** @returns xcb_void_cookie_t 8770 ** 8771 *****************************************************************************/ 8772 8773 xcb_void_cookie_t 8774 xcb_set_clip_rectangles (xcb_connection_t *c /**< */, 8775 uint8_t ordering /**< */, 8776 xcb_gcontext_t gc /**< */, 8777 int16_t clip_x_origin /**< */, 8778 int16_t clip_y_origin /**< */, 8779 uint32_t rectangles_len /**< */, 8780 const xcb_rectangle_t *rectangles /**< */) 8781 { 8782 static const xcb_protocol_request_t xcb_req = { 8783 /* count */ 4, 8784 /* ext */ 0, 8785 /* opcode */ XCB_SET_CLIP_RECTANGLES, 8786 /* isvoid */ 1 8787 }; 8788 8789 struct iovec xcb_parts[6]; 8790 xcb_void_cookie_t xcb_ret; 8791 xcb_set_clip_rectangles_request_t xcb_out; 8792 8793 xcb_out.ordering = ordering; 8794 xcb_out.gc = gc; 8795 xcb_out.clip_x_origin = clip_x_origin; 8796 xcb_out.clip_y_origin = clip_y_origin; 8797 8798 xcb_parts[2].iov_base = (char *) &xcb_out; 8799 xcb_parts[2].iov_len = sizeof(xcb_out); 8800 xcb_parts[3].iov_base = 0; 8801 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8802 /* xcb_rectangle_t rectangles */ 8803 xcb_parts[4].iov_base = (char *) rectangles; 8804 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 8805 xcb_parts[5].iov_base = 0; 8806 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 8807 8808 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8809 return xcb_ret; 8810 } 8811 8812 8813 /***************************************************************************** 8814 ** 8815 ** xcb_void_cookie_t xcb_free_gc_checked 8816 ** 8817 ** @param xcb_connection_t *c 8818 ** @param xcb_gcontext_t gc 8819 ** @returns xcb_void_cookie_t 8820 ** 8821 *****************************************************************************/ 8822 8823 xcb_void_cookie_t 8824 xcb_free_gc_checked (xcb_connection_t *c /**< */, 8825 xcb_gcontext_t gc /**< */) 8826 { 8827 static const xcb_protocol_request_t xcb_req = { 8828 /* count */ 2, 8829 /* ext */ 0, 8830 /* opcode */ XCB_FREE_GC, 8831 /* isvoid */ 1 8832 }; 8833 8834 struct iovec xcb_parts[4]; 8835 xcb_void_cookie_t xcb_ret; 8836 xcb_free_gc_request_t xcb_out; 8837 8838 xcb_out.pad0 = 0; 8839 xcb_out.gc = gc; 8840 8841 xcb_parts[2].iov_base = (char *) &xcb_out; 8842 xcb_parts[2].iov_len = sizeof(xcb_out); 8843 xcb_parts[3].iov_base = 0; 8844 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8845 8846 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8847 return xcb_ret; 8848 } 8849 8850 8851 /***************************************************************************** 8852 ** 8853 ** xcb_void_cookie_t xcb_free_gc 8854 ** 8855 ** @param xcb_connection_t *c 8856 ** @param xcb_gcontext_t gc 8857 ** @returns xcb_void_cookie_t 8858 ** 8859 *****************************************************************************/ 8860 8861 xcb_void_cookie_t 8862 xcb_free_gc (xcb_connection_t *c /**< */, 8863 xcb_gcontext_t gc /**< */) 8864 { 8865 static const xcb_protocol_request_t xcb_req = { 8866 /* count */ 2, 8867 /* ext */ 0, 8868 /* opcode */ XCB_FREE_GC, 8869 /* isvoid */ 1 8870 }; 8871 8872 struct iovec xcb_parts[4]; 8873 xcb_void_cookie_t xcb_ret; 8874 xcb_free_gc_request_t xcb_out; 8875 8876 xcb_out.pad0 = 0; 8877 xcb_out.gc = gc; 8878 8879 xcb_parts[2].iov_base = (char *) &xcb_out; 8880 xcb_parts[2].iov_len = sizeof(xcb_out); 8881 xcb_parts[3].iov_base = 0; 8882 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8883 8884 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8885 return xcb_ret; 8886 } 8887 8888 8889 /***************************************************************************** 8890 ** 8891 ** xcb_void_cookie_t xcb_clear_area_checked 8892 ** 8893 ** @param xcb_connection_t *c 8894 ** @param uint8_t exposures 8895 ** @param xcb_window_t window 8896 ** @param int16_t x 8897 ** @param int16_t y 8898 ** @param uint16_t width 8899 ** @param uint16_t height 8900 ** @returns xcb_void_cookie_t 8901 ** 8902 *****************************************************************************/ 8903 8904 xcb_void_cookie_t 8905 xcb_clear_area_checked (xcb_connection_t *c /**< */, 8906 uint8_t exposures /**< */, 8907 xcb_window_t window /**< */, 8908 int16_t x /**< */, 8909 int16_t y /**< */, 8910 uint16_t width /**< */, 8911 uint16_t height /**< */) 8912 { 8913 static const xcb_protocol_request_t xcb_req = { 8914 /* count */ 2, 8915 /* ext */ 0, 8916 /* opcode */ XCB_CLEAR_AREA, 8917 /* isvoid */ 1 8918 }; 8919 8920 struct iovec xcb_parts[4]; 8921 xcb_void_cookie_t xcb_ret; 8922 xcb_clear_area_request_t xcb_out; 8923 8924 xcb_out.exposures = exposures; 8925 xcb_out.window = window; 8926 xcb_out.x = x; 8927 xcb_out.y = y; 8928 xcb_out.width = width; 8929 xcb_out.height = height; 8930 8931 xcb_parts[2].iov_base = (char *) &xcb_out; 8932 xcb_parts[2].iov_len = sizeof(xcb_out); 8933 xcb_parts[3].iov_base = 0; 8934 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8935 8936 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 8937 return xcb_ret; 8938 } 8939 8940 8941 /***************************************************************************** 8942 ** 8943 ** xcb_void_cookie_t xcb_clear_area 8944 ** 8945 ** @param xcb_connection_t *c 8946 ** @param uint8_t exposures 8947 ** @param xcb_window_t window 8948 ** @param int16_t x 8949 ** @param int16_t y 8950 ** @param uint16_t width 8951 ** @param uint16_t height 8952 ** @returns xcb_void_cookie_t 8953 ** 8954 *****************************************************************************/ 8955 8956 xcb_void_cookie_t 8957 xcb_clear_area (xcb_connection_t *c /**< */, 8958 uint8_t exposures /**< */, 8959 xcb_window_t window /**< */, 8960 int16_t x /**< */, 8961 int16_t y /**< */, 8962 uint16_t width /**< */, 8963 uint16_t height /**< */) 8964 { 8965 static const xcb_protocol_request_t xcb_req = { 8966 /* count */ 2, 8967 /* ext */ 0, 8968 /* opcode */ XCB_CLEAR_AREA, 8969 /* isvoid */ 1 8970 }; 8971 8972 struct iovec xcb_parts[4]; 8973 xcb_void_cookie_t xcb_ret; 8974 xcb_clear_area_request_t xcb_out; 8975 8976 xcb_out.exposures = exposures; 8977 xcb_out.window = window; 8978 xcb_out.x = x; 8979 xcb_out.y = y; 8980 xcb_out.width = width; 8981 xcb_out.height = height; 8982 8983 xcb_parts[2].iov_base = (char *) &xcb_out; 8984 xcb_parts[2].iov_len = sizeof(xcb_out); 8985 xcb_parts[3].iov_base = 0; 8986 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 8987 8988 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 8989 return xcb_ret; 8990 } 8991 8992 8993 /***************************************************************************** 8994 ** 8995 ** xcb_void_cookie_t xcb_copy_area_checked 8996 ** 8997 ** @param xcb_connection_t *c 8998 ** @param xcb_drawable_t src_drawable 8999 ** @param xcb_drawable_t dst_drawable 9000 ** @param xcb_gcontext_t gc 9001 ** @param int16_t src_x 9002 ** @param int16_t src_y 9003 ** @param int16_t dst_x 9004 ** @param int16_t dst_y 9005 ** @param uint16_t width 9006 ** @param uint16_t height 9007 ** @returns xcb_void_cookie_t 9008 ** 9009 *****************************************************************************/ 9010 9011 xcb_void_cookie_t 9012 xcb_copy_area_checked (xcb_connection_t *c /**< */, 9013 xcb_drawable_t src_drawable /**< */, 9014 xcb_drawable_t dst_drawable /**< */, 9015 xcb_gcontext_t gc /**< */, 9016 int16_t src_x /**< */, 9017 int16_t src_y /**< */, 9018 int16_t dst_x /**< */, 9019 int16_t dst_y /**< */, 9020 uint16_t width /**< */, 9021 uint16_t height /**< */) 9022 { 9023 static const xcb_protocol_request_t xcb_req = { 9024 /* count */ 2, 9025 /* ext */ 0, 9026 /* opcode */ XCB_COPY_AREA, 9027 /* isvoid */ 1 9028 }; 9029 9030 struct iovec xcb_parts[4]; 9031 xcb_void_cookie_t xcb_ret; 9032 xcb_copy_area_request_t xcb_out; 9033 9034 xcb_out.pad0 = 0; 9035 xcb_out.src_drawable = src_drawable; 9036 xcb_out.dst_drawable = dst_drawable; 9037 xcb_out.gc = gc; 9038 xcb_out.src_x = src_x; 9039 xcb_out.src_y = src_y; 9040 xcb_out.dst_x = dst_x; 9041 xcb_out.dst_y = dst_y; 9042 xcb_out.width = width; 9043 xcb_out.height = height; 9044 9045 xcb_parts[2].iov_base = (char *) &xcb_out; 9046 xcb_parts[2].iov_len = sizeof(xcb_out); 9047 xcb_parts[3].iov_base = 0; 9048 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9049 9050 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9051 return xcb_ret; 9052 } 9053 9054 9055 /***************************************************************************** 9056 ** 9057 ** xcb_void_cookie_t xcb_copy_area 9058 ** 9059 ** @param xcb_connection_t *c 9060 ** @param xcb_drawable_t src_drawable 9061 ** @param xcb_drawable_t dst_drawable 9062 ** @param xcb_gcontext_t gc 9063 ** @param int16_t src_x 9064 ** @param int16_t src_y 9065 ** @param int16_t dst_x 9066 ** @param int16_t dst_y 9067 ** @param uint16_t width 9068 ** @param uint16_t height 9069 ** @returns xcb_void_cookie_t 9070 ** 9071 *****************************************************************************/ 9072 9073 xcb_void_cookie_t 9074 xcb_copy_area (xcb_connection_t *c /**< */, 9075 xcb_drawable_t src_drawable /**< */, 9076 xcb_drawable_t dst_drawable /**< */, 9077 xcb_gcontext_t gc /**< */, 9078 int16_t src_x /**< */, 9079 int16_t src_y /**< */, 9080 int16_t dst_x /**< */, 9081 int16_t dst_y /**< */, 9082 uint16_t width /**< */, 9083 uint16_t height /**< */) 9084 { 9085 static const xcb_protocol_request_t xcb_req = { 9086 /* count */ 2, 9087 /* ext */ 0, 9088 /* opcode */ XCB_COPY_AREA, 9089 /* isvoid */ 1 9090 }; 9091 9092 struct iovec xcb_parts[4]; 9093 xcb_void_cookie_t xcb_ret; 9094 xcb_copy_area_request_t xcb_out; 9095 9096 xcb_out.pad0 = 0; 9097 xcb_out.src_drawable = src_drawable; 9098 xcb_out.dst_drawable = dst_drawable; 9099 xcb_out.gc = gc; 9100 xcb_out.src_x = src_x; 9101 xcb_out.src_y = src_y; 9102 xcb_out.dst_x = dst_x; 9103 xcb_out.dst_y = dst_y; 9104 xcb_out.width = width; 9105 xcb_out.height = height; 9106 9107 xcb_parts[2].iov_base = (char *) &xcb_out; 9108 xcb_parts[2].iov_len = sizeof(xcb_out); 9109 xcb_parts[3].iov_base = 0; 9110 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9111 9112 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9113 return xcb_ret; 9114 } 9115 9116 9117 /***************************************************************************** 9118 ** 9119 ** xcb_void_cookie_t xcb_copy_plane_checked 9120 ** 9121 ** @param xcb_connection_t *c 9122 ** @param xcb_drawable_t src_drawable 9123 ** @param xcb_drawable_t dst_drawable 9124 ** @param xcb_gcontext_t gc 9125 ** @param int16_t src_x 9126 ** @param int16_t src_y 9127 ** @param int16_t dst_x 9128 ** @param int16_t dst_y 9129 ** @param uint16_t width 9130 ** @param uint16_t height 9131 ** @param uint32_t bit_plane 9132 ** @returns xcb_void_cookie_t 9133 ** 9134 *****************************************************************************/ 9135 9136 xcb_void_cookie_t 9137 xcb_copy_plane_checked (xcb_connection_t *c /**< */, 9138 xcb_drawable_t src_drawable /**< */, 9139 xcb_drawable_t dst_drawable /**< */, 9140 xcb_gcontext_t gc /**< */, 9141 int16_t src_x /**< */, 9142 int16_t src_y /**< */, 9143 int16_t dst_x /**< */, 9144 int16_t dst_y /**< */, 9145 uint16_t width /**< */, 9146 uint16_t height /**< */, 9147 uint32_t bit_plane /**< */) 9148 { 9149 static const xcb_protocol_request_t xcb_req = { 9150 /* count */ 2, 9151 /* ext */ 0, 9152 /* opcode */ XCB_COPY_PLANE, 9153 /* isvoid */ 1 9154 }; 9155 9156 struct iovec xcb_parts[4]; 9157 xcb_void_cookie_t xcb_ret; 9158 xcb_copy_plane_request_t xcb_out; 9159 9160 xcb_out.pad0 = 0; 9161 xcb_out.src_drawable = src_drawable; 9162 xcb_out.dst_drawable = dst_drawable; 9163 xcb_out.gc = gc; 9164 xcb_out.src_x = src_x; 9165 xcb_out.src_y = src_y; 9166 xcb_out.dst_x = dst_x; 9167 xcb_out.dst_y = dst_y; 9168 xcb_out.width = width; 9169 xcb_out.height = height; 9170 xcb_out.bit_plane = bit_plane; 9171 9172 xcb_parts[2].iov_base = (char *) &xcb_out; 9173 xcb_parts[2].iov_len = sizeof(xcb_out); 9174 xcb_parts[3].iov_base = 0; 9175 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9176 9177 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9178 return xcb_ret; 9179 } 9180 9181 9182 /***************************************************************************** 9183 ** 9184 ** xcb_void_cookie_t xcb_copy_plane 9185 ** 9186 ** @param xcb_connection_t *c 9187 ** @param xcb_drawable_t src_drawable 9188 ** @param xcb_drawable_t dst_drawable 9189 ** @param xcb_gcontext_t gc 9190 ** @param int16_t src_x 9191 ** @param int16_t src_y 9192 ** @param int16_t dst_x 9193 ** @param int16_t dst_y 9194 ** @param uint16_t width 9195 ** @param uint16_t height 9196 ** @param uint32_t bit_plane 9197 ** @returns xcb_void_cookie_t 9198 ** 9199 *****************************************************************************/ 9200 9201 xcb_void_cookie_t 9202 xcb_copy_plane (xcb_connection_t *c /**< */, 9203 xcb_drawable_t src_drawable /**< */, 9204 xcb_drawable_t dst_drawable /**< */, 9205 xcb_gcontext_t gc /**< */, 9206 int16_t src_x /**< */, 9207 int16_t src_y /**< */, 9208 int16_t dst_x /**< */, 9209 int16_t dst_y /**< */, 9210 uint16_t width /**< */, 9211 uint16_t height /**< */, 9212 uint32_t bit_plane /**< */) 9213 { 9214 static const xcb_protocol_request_t xcb_req = { 9215 /* count */ 2, 9216 /* ext */ 0, 9217 /* opcode */ XCB_COPY_PLANE, 9218 /* isvoid */ 1 9219 }; 9220 9221 struct iovec xcb_parts[4]; 9222 xcb_void_cookie_t xcb_ret; 9223 xcb_copy_plane_request_t xcb_out; 9224 9225 xcb_out.pad0 = 0; 9226 xcb_out.src_drawable = src_drawable; 9227 xcb_out.dst_drawable = dst_drawable; 9228 xcb_out.gc = gc; 9229 xcb_out.src_x = src_x; 9230 xcb_out.src_y = src_y; 9231 xcb_out.dst_x = dst_x; 9232 xcb_out.dst_y = dst_y; 9233 xcb_out.width = width; 9234 xcb_out.height = height; 9235 xcb_out.bit_plane = bit_plane; 9236 9237 xcb_parts[2].iov_base = (char *) &xcb_out; 9238 xcb_parts[2].iov_len = sizeof(xcb_out); 9239 xcb_parts[3].iov_base = 0; 9240 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9241 9242 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9243 return xcb_ret; 9244 } 9245 9246 int 9247 xcb_poly_point_sizeof (const void *_buffer /**< */, 9248 uint32_t points_len /**< */) 9249 { 9250 char *xcb_tmp = (char *)_buffer; 9251 unsigned int xcb_buffer_len = 0; 9252 unsigned int xcb_block_len = 0; 9253 unsigned int xcb_pad = 0; 9254 unsigned int xcb_align_to; 9255 9256 9257 xcb_block_len += sizeof(xcb_poly_point_request_t); 9258 xcb_tmp += xcb_block_len; 9259 /* points */ 9260 xcb_block_len += points_len * sizeof(xcb_point_t); 9261 xcb_tmp += xcb_block_len; 9262 xcb_align_to = ALIGNOF(xcb_point_t); 9263 /* insert padding */ 9264 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9265 xcb_buffer_len += xcb_block_len + xcb_pad; 9266 if (0 != xcb_pad) { 9267 xcb_tmp += xcb_pad; 9268 xcb_pad = 0; 9269 } 9270 xcb_block_len = 0; 9271 9272 return xcb_buffer_len; 9273 } 9274 9275 9276 /***************************************************************************** 9277 ** 9278 ** xcb_void_cookie_t xcb_poly_point_checked 9279 ** 9280 ** @param xcb_connection_t *c 9281 ** @param uint8_t coordinate_mode 9282 ** @param xcb_drawable_t drawable 9283 ** @param xcb_gcontext_t gc 9284 ** @param uint32_t points_len 9285 ** @param const xcb_point_t *points 9286 ** @returns xcb_void_cookie_t 9287 ** 9288 *****************************************************************************/ 9289 9290 xcb_void_cookie_t 9291 xcb_poly_point_checked (xcb_connection_t *c /**< */, 9292 uint8_t coordinate_mode /**< */, 9293 xcb_drawable_t drawable /**< */, 9294 xcb_gcontext_t gc /**< */, 9295 uint32_t points_len /**< */, 9296 const xcb_point_t *points /**< */) 9297 { 9298 static const xcb_protocol_request_t xcb_req = { 9299 /* count */ 4, 9300 /* ext */ 0, 9301 /* opcode */ XCB_POLY_POINT, 9302 /* isvoid */ 1 9303 }; 9304 9305 struct iovec xcb_parts[6]; 9306 xcb_void_cookie_t xcb_ret; 9307 xcb_poly_point_request_t xcb_out; 9308 9309 xcb_out.coordinate_mode = coordinate_mode; 9310 xcb_out.drawable = drawable; 9311 xcb_out.gc = gc; 9312 9313 xcb_parts[2].iov_base = (char *) &xcb_out; 9314 xcb_parts[2].iov_len = sizeof(xcb_out); 9315 xcb_parts[3].iov_base = 0; 9316 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9317 /* xcb_point_t points */ 9318 xcb_parts[4].iov_base = (char *) points; 9319 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 9320 xcb_parts[5].iov_base = 0; 9321 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9322 9323 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9324 return xcb_ret; 9325 } 9326 9327 9328 /***************************************************************************** 9329 ** 9330 ** xcb_void_cookie_t xcb_poly_point 9331 ** 9332 ** @param xcb_connection_t *c 9333 ** @param uint8_t coordinate_mode 9334 ** @param xcb_drawable_t drawable 9335 ** @param xcb_gcontext_t gc 9336 ** @param uint32_t points_len 9337 ** @param const xcb_point_t *points 9338 ** @returns xcb_void_cookie_t 9339 ** 9340 *****************************************************************************/ 9341 9342 xcb_void_cookie_t 9343 xcb_poly_point (xcb_connection_t *c /**< */, 9344 uint8_t coordinate_mode /**< */, 9345 xcb_drawable_t drawable /**< */, 9346 xcb_gcontext_t gc /**< */, 9347 uint32_t points_len /**< */, 9348 const xcb_point_t *points /**< */) 9349 { 9350 static const xcb_protocol_request_t xcb_req = { 9351 /* count */ 4, 9352 /* ext */ 0, 9353 /* opcode */ XCB_POLY_POINT, 9354 /* isvoid */ 1 9355 }; 9356 9357 struct iovec xcb_parts[6]; 9358 xcb_void_cookie_t xcb_ret; 9359 xcb_poly_point_request_t xcb_out; 9360 9361 xcb_out.coordinate_mode = coordinate_mode; 9362 xcb_out.drawable = drawable; 9363 xcb_out.gc = gc; 9364 9365 xcb_parts[2].iov_base = (char *) &xcb_out; 9366 xcb_parts[2].iov_len = sizeof(xcb_out); 9367 xcb_parts[3].iov_base = 0; 9368 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9369 /* xcb_point_t points */ 9370 xcb_parts[4].iov_base = (char *) points; 9371 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 9372 xcb_parts[5].iov_base = 0; 9373 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9374 9375 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9376 return xcb_ret; 9377 } 9378 9379 int 9380 xcb_poly_line_sizeof (const void *_buffer /**< */, 9381 uint32_t points_len /**< */) 9382 { 9383 char *xcb_tmp = (char *)_buffer; 9384 unsigned int xcb_buffer_len = 0; 9385 unsigned int xcb_block_len = 0; 9386 unsigned int xcb_pad = 0; 9387 unsigned int xcb_align_to; 9388 9389 9390 xcb_block_len += sizeof(xcb_poly_line_request_t); 9391 xcb_tmp += xcb_block_len; 9392 /* points */ 9393 xcb_block_len += points_len * sizeof(xcb_point_t); 9394 xcb_tmp += xcb_block_len; 9395 xcb_align_to = ALIGNOF(xcb_point_t); 9396 /* insert padding */ 9397 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9398 xcb_buffer_len += xcb_block_len + xcb_pad; 9399 if (0 != xcb_pad) { 9400 xcb_tmp += xcb_pad; 9401 xcb_pad = 0; 9402 } 9403 xcb_block_len = 0; 9404 9405 return xcb_buffer_len; 9406 } 9407 9408 9409 /***************************************************************************** 9410 ** 9411 ** xcb_void_cookie_t xcb_poly_line_checked 9412 ** 9413 ** @param xcb_connection_t *c 9414 ** @param uint8_t coordinate_mode 9415 ** @param xcb_drawable_t drawable 9416 ** @param xcb_gcontext_t gc 9417 ** @param uint32_t points_len 9418 ** @param const xcb_point_t *points 9419 ** @returns xcb_void_cookie_t 9420 ** 9421 *****************************************************************************/ 9422 9423 xcb_void_cookie_t 9424 xcb_poly_line_checked (xcb_connection_t *c /**< */, 9425 uint8_t coordinate_mode /**< */, 9426 xcb_drawable_t drawable /**< */, 9427 xcb_gcontext_t gc /**< */, 9428 uint32_t points_len /**< */, 9429 const xcb_point_t *points /**< */) 9430 { 9431 static const xcb_protocol_request_t xcb_req = { 9432 /* count */ 4, 9433 /* ext */ 0, 9434 /* opcode */ XCB_POLY_LINE, 9435 /* isvoid */ 1 9436 }; 9437 9438 struct iovec xcb_parts[6]; 9439 xcb_void_cookie_t xcb_ret; 9440 xcb_poly_line_request_t xcb_out; 9441 9442 xcb_out.coordinate_mode = coordinate_mode; 9443 xcb_out.drawable = drawable; 9444 xcb_out.gc = gc; 9445 9446 xcb_parts[2].iov_base = (char *) &xcb_out; 9447 xcb_parts[2].iov_len = sizeof(xcb_out); 9448 xcb_parts[3].iov_base = 0; 9449 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9450 /* xcb_point_t points */ 9451 xcb_parts[4].iov_base = (char *) points; 9452 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 9453 xcb_parts[5].iov_base = 0; 9454 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9455 9456 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9457 return xcb_ret; 9458 } 9459 9460 9461 /***************************************************************************** 9462 ** 9463 ** xcb_void_cookie_t xcb_poly_line 9464 ** 9465 ** @param xcb_connection_t *c 9466 ** @param uint8_t coordinate_mode 9467 ** @param xcb_drawable_t drawable 9468 ** @param xcb_gcontext_t gc 9469 ** @param uint32_t points_len 9470 ** @param const xcb_point_t *points 9471 ** @returns xcb_void_cookie_t 9472 ** 9473 *****************************************************************************/ 9474 9475 xcb_void_cookie_t 9476 xcb_poly_line (xcb_connection_t *c /**< */, 9477 uint8_t coordinate_mode /**< */, 9478 xcb_drawable_t drawable /**< */, 9479 xcb_gcontext_t gc /**< */, 9480 uint32_t points_len /**< */, 9481 const xcb_point_t *points /**< */) 9482 { 9483 static const xcb_protocol_request_t xcb_req = { 9484 /* count */ 4, 9485 /* ext */ 0, 9486 /* opcode */ XCB_POLY_LINE, 9487 /* isvoid */ 1 9488 }; 9489 9490 struct iovec xcb_parts[6]; 9491 xcb_void_cookie_t xcb_ret; 9492 xcb_poly_line_request_t xcb_out; 9493 9494 xcb_out.coordinate_mode = coordinate_mode; 9495 xcb_out.drawable = drawable; 9496 xcb_out.gc = gc; 9497 9498 xcb_parts[2].iov_base = (char *) &xcb_out; 9499 xcb_parts[2].iov_len = sizeof(xcb_out); 9500 xcb_parts[3].iov_base = 0; 9501 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9502 /* xcb_point_t points */ 9503 xcb_parts[4].iov_base = (char *) points; 9504 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 9505 xcb_parts[5].iov_base = 0; 9506 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9507 9508 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9509 return xcb_ret; 9510 } 9511 9512 9513 /***************************************************************************** 9514 ** 9515 ** void xcb_segment_next 9516 ** 9517 ** @param xcb_segment_iterator_t *i 9518 ** @returns void 9519 ** 9520 *****************************************************************************/ 9521 9522 void 9523 xcb_segment_next (xcb_segment_iterator_t *i /**< */) 9524 { 9525 --i->rem; 9526 ++i->data; 9527 i->index += sizeof(xcb_segment_t); 9528 } 9529 9530 9531 /***************************************************************************** 9532 ** 9533 ** xcb_generic_iterator_t xcb_segment_end 9534 ** 9535 ** @param xcb_segment_iterator_t i 9536 ** @returns xcb_generic_iterator_t 9537 ** 9538 *****************************************************************************/ 9539 9540 xcb_generic_iterator_t 9541 xcb_segment_end (xcb_segment_iterator_t i /**< */) 9542 { 9543 xcb_generic_iterator_t ret; 9544 ret.data = i.data + i.rem; 9545 ret.index = i.index + ((char *) ret.data - (char *) i.data); 9546 ret.rem = 0; 9547 return ret; 9548 } 9549 9550 int 9551 xcb_poly_segment_sizeof (const void *_buffer /**< */, 9552 uint32_t segments_len /**< */) 9553 { 9554 char *xcb_tmp = (char *)_buffer; 9555 unsigned int xcb_buffer_len = 0; 9556 unsigned int xcb_block_len = 0; 9557 unsigned int xcb_pad = 0; 9558 unsigned int xcb_align_to; 9559 9560 9561 xcb_block_len += sizeof(xcb_poly_segment_request_t); 9562 xcb_tmp += xcb_block_len; 9563 /* segments */ 9564 xcb_block_len += segments_len * sizeof(xcb_segment_t); 9565 xcb_tmp += xcb_block_len; 9566 xcb_align_to = ALIGNOF(xcb_segment_t); 9567 /* insert padding */ 9568 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9569 xcb_buffer_len += xcb_block_len + xcb_pad; 9570 if (0 != xcb_pad) { 9571 xcb_tmp += xcb_pad; 9572 xcb_pad = 0; 9573 } 9574 xcb_block_len = 0; 9575 9576 return xcb_buffer_len; 9577 } 9578 9579 9580 /***************************************************************************** 9581 ** 9582 ** xcb_void_cookie_t xcb_poly_segment_checked 9583 ** 9584 ** @param xcb_connection_t *c 9585 ** @param xcb_drawable_t drawable 9586 ** @param xcb_gcontext_t gc 9587 ** @param uint32_t segments_len 9588 ** @param const xcb_segment_t *segments 9589 ** @returns xcb_void_cookie_t 9590 ** 9591 *****************************************************************************/ 9592 9593 xcb_void_cookie_t 9594 xcb_poly_segment_checked (xcb_connection_t *c /**< */, 9595 xcb_drawable_t drawable /**< */, 9596 xcb_gcontext_t gc /**< */, 9597 uint32_t segments_len /**< */, 9598 const xcb_segment_t *segments /**< */) 9599 { 9600 static const xcb_protocol_request_t xcb_req = { 9601 /* count */ 4, 9602 /* ext */ 0, 9603 /* opcode */ XCB_POLY_SEGMENT, 9604 /* isvoid */ 1 9605 }; 9606 9607 struct iovec xcb_parts[6]; 9608 xcb_void_cookie_t xcb_ret; 9609 xcb_poly_segment_request_t xcb_out; 9610 9611 xcb_out.pad0 = 0; 9612 xcb_out.drawable = drawable; 9613 xcb_out.gc = gc; 9614 9615 xcb_parts[2].iov_base = (char *) &xcb_out; 9616 xcb_parts[2].iov_len = sizeof(xcb_out); 9617 xcb_parts[3].iov_base = 0; 9618 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9619 /* xcb_segment_t segments */ 9620 xcb_parts[4].iov_base = (char *) segments; 9621 xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t); 9622 xcb_parts[5].iov_base = 0; 9623 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9624 9625 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9626 return xcb_ret; 9627 } 9628 9629 9630 /***************************************************************************** 9631 ** 9632 ** xcb_void_cookie_t xcb_poly_segment 9633 ** 9634 ** @param xcb_connection_t *c 9635 ** @param xcb_drawable_t drawable 9636 ** @param xcb_gcontext_t gc 9637 ** @param uint32_t segments_len 9638 ** @param const xcb_segment_t *segments 9639 ** @returns xcb_void_cookie_t 9640 ** 9641 *****************************************************************************/ 9642 9643 xcb_void_cookie_t 9644 xcb_poly_segment (xcb_connection_t *c /**< */, 9645 xcb_drawable_t drawable /**< */, 9646 xcb_gcontext_t gc /**< */, 9647 uint32_t segments_len /**< */, 9648 const xcb_segment_t *segments /**< */) 9649 { 9650 static const xcb_protocol_request_t xcb_req = { 9651 /* count */ 4, 9652 /* ext */ 0, 9653 /* opcode */ XCB_POLY_SEGMENT, 9654 /* isvoid */ 1 9655 }; 9656 9657 struct iovec xcb_parts[6]; 9658 xcb_void_cookie_t xcb_ret; 9659 xcb_poly_segment_request_t xcb_out; 9660 9661 xcb_out.pad0 = 0; 9662 xcb_out.drawable = drawable; 9663 xcb_out.gc = gc; 9664 9665 xcb_parts[2].iov_base = (char *) &xcb_out; 9666 xcb_parts[2].iov_len = sizeof(xcb_out); 9667 xcb_parts[3].iov_base = 0; 9668 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9669 /* xcb_segment_t segments */ 9670 xcb_parts[4].iov_base = (char *) segments; 9671 xcb_parts[4].iov_len = segments_len * sizeof(xcb_segment_t); 9672 xcb_parts[5].iov_base = 0; 9673 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9674 9675 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9676 return xcb_ret; 9677 } 9678 9679 int 9680 xcb_poly_rectangle_sizeof (const void *_buffer /**< */, 9681 uint32_t rectangles_len /**< */) 9682 { 9683 char *xcb_tmp = (char *)_buffer; 9684 unsigned int xcb_buffer_len = 0; 9685 unsigned int xcb_block_len = 0; 9686 unsigned int xcb_pad = 0; 9687 unsigned int xcb_align_to; 9688 9689 9690 xcb_block_len += sizeof(xcb_poly_rectangle_request_t); 9691 xcb_tmp += xcb_block_len; 9692 /* rectangles */ 9693 xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); 9694 xcb_tmp += xcb_block_len; 9695 xcb_align_to = ALIGNOF(xcb_rectangle_t); 9696 /* insert padding */ 9697 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9698 xcb_buffer_len += xcb_block_len + xcb_pad; 9699 if (0 != xcb_pad) { 9700 xcb_tmp += xcb_pad; 9701 xcb_pad = 0; 9702 } 9703 xcb_block_len = 0; 9704 9705 return xcb_buffer_len; 9706 } 9707 9708 9709 /***************************************************************************** 9710 ** 9711 ** xcb_void_cookie_t xcb_poly_rectangle_checked 9712 ** 9713 ** @param xcb_connection_t *c 9714 ** @param xcb_drawable_t drawable 9715 ** @param xcb_gcontext_t gc 9716 ** @param uint32_t rectangles_len 9717 ** @param const xcb_rectangle_t *rectangles 9718 ** @returns xcb_void_cookie_t 9719 ** 9720 *****************************************************************************/ 9721 9722 xcb_void_cookie_t 9723 xcb_poly_rectangle_checked (xcb_connection_t *c /**< */, 9724 xcb_drawable_t drawable /**< */, 9725 xcb_gcontext_t gc /**< */, 9726 uint32_t rectangles_len /**< */, 9727 const xcb_rectangle_t *rectangles /**< */) 9728 { 9729 static const xcb_protocol_request_t xcb_req = { 9730 /* count */ 4, 9731 /* ext */ 0, 9732 /* opcode */ XCB_POLY_RECTANGLE, 9733 /* isvoid */ 1 9734 }; 9735 9736 struct iovec xcb_parts[6]; 9737 xcb_void_cookie_t xcb_ret; 9738 xcb_poly_rectangle_request_t xcb_out; 9739 9740 xcb_out.pad0 = 0; 9741 xcb_out.drawable = drawable; 9742 xcb_out.gc = gc; 9743 9744 xcb_parts[2].iov_base = (char *) &xcb_out; 9745 xcb_parts[2].iov_len = sizeof(xcb_out); 9746 xcb_parts[3].iov_base = 0; 9747 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9748 /* xcb_rectangle_t rectangles */ 9749 xcb_parts[4].iov_base = (char *) rectangles; 9750 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 9751 xcb_parts[5].iov_base = 0; 9752 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9753 9754 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9755 return xcb_ret; 9756 } 9757 9758 9759 /***************************************************************************** 9760 ** 9761 ** xcb_void_cookie_t xcb_poly_rectangle 9762 ** 9763 ** @param xcb_connection_t *c 9764 ** @param xcb_drawable_t drawable 9765 ** @param xcb_gcontext_t gc 9766 ** @param uint32_t rectangles_len 9767 ** @param const xcb_rectangle_t *rectangles 9768 ** @returns xcb_void_cookie_t 9769 ** 9770 *****************************************************************************/ 9771 9772 xcb_void_cookie_t 9773 xcb_poly_rectangle (xcb_connection_t *c /**< */, 9774 xcb_drawable_t drawable /**< */, 9775 xcb_gcontext_t gc /**< */, 9776 uint32_t rectangles_len /**< */, 9777 const xcb_rectangle_t *rectangles /**< */) 9778 { 9779 static const xcb_protocol_request_t xcb_req = { 9780 /* count */ 4, 9781 /* ext */ 0, 9782 /* opcode */ XCB_POLY_RECTANGLE, 9783 /* isvoid */ 1 9784 }; 9785 9786 struct iovec xcb_parts[6]; 9787 xcb_void_cookie_t xcb_ret; 9788 xcb_poly_rectangle_request_t xcb_out; 9789 9790 xcb_out.pad0 = 0; 9791 xcb_out.drawable = drawable; 9792 xcb_out.gc = gc; 9793 9794 xcb_parts[2].iov_base = (char *) &xcb_out; 9795 xcb_parts[2].iov_len = sizeof(xcb_out); 9796 xcb_parts[3].iov_base = 0; 9797 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9798 /* xcb_rectangle_t rectangles */ 9799 xcb_parts[4].iov_base = (char *) rectangles; 9800 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 9801 xcb_parts[5].iov_base = 0; 9802 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9803 9804 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9805 return xcb_ret; 9806 } 9807 9808 int 9809 xcb_poly_arc_sizeof (const void *_buffer /**< */, 9810 uint32_t arcs_len /**< */) 9811 { 9812 char *xcb_tmp = (char *)_buffer; 9813 unsigned int xcb_buffer_len = 0; 9814 unsigned int xcb_block_len = 0; 9815 unsigned int xcb_pad = 0; 9816 unsigned int xcb_align_to; 9817 9818 9819 xcb_block_len += sizeof(xcb_poly_arc_request_t); 9820 xcb_tmp += xcb_block_len; 9821 /* arcs */ 9822 xcb_block_len += arcs_len * sizeof(xcb_arc_t); 9823 xcb_tmp += xcb_block_len; 9824 xcb_align_to = ALIGNOF(xcb_arc_t); 9825 /* insert padding */ 9826 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9827 xcb_buffer_len += xcb_block_len + xcb_pad; 9828 if (0 != xcb_pad) { 9829 xcb_tmp += xcb_pad; 9830 xcb_pad = 0; 9831 } 9832 xcb_block_len = 0; 9833 9834 return xcb_buffer_len; 9835 } 9836 9837 9838 /***************************************************************************** 9839 ** 9840 ** xcb_void_cookie_t xcb_poly_arc_checked 9841 ** 9842 ** @param xcb_connection_t *c 9843 ** @param xcb_drawable_t drawable 9844 ** @param xcb_gcontext_t gc 9845 ** @param uint32_t arcs_len 9846 ** @param const xcb_arc_t *arcs 9847 ** @returns xcb_void_cookie_t 9848 ** 9849 *****************************************************************************/ 9850 9851 xcb_void_cookie_t 9852 xcb_poly_arc_checked (xcb_connection_t *c /**< */, 9853 xcb_drawable_t drawable /**< */, 9854 xcb_gcontext_t gc /**< */, 9855 uint32_t arcs_len /**< */, 9856 const xcb_arc_t *arcs /**< */) 9857 { 9858 static const xcb_protocol_request_t xcb_req = { 9859 /* count */ 4, 9860 /* ext */ 0, 9861 /* opcode */ XCB_POLY_ARC, 9862 /* isvoid */ 1 9863 }; 9864 9865 struct iovec xcb_parts[6]; 9866 xcb_void_cookie_t xcb_ret; 9867 xcb_poly_arc_request_t xcb_out; 9868 9869 xcb_out.pad0 = 0; 9870 xcb_out.drawable = drawable; 9871 xcb_out.gc = gc; 9872 9873 xcb_parts[2].iov_base = (char *) &xcb_out; 9874 xcb_parts[2].iov_len = sizeof(xcb_out); 9875 xcb_parts[3].iov_base = 0; 9876 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9877 /* xcb_arc_t arcs */ 9878 xcb_parts[4].iov_base = (char *) arcs; 9879 xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t); 9880 xcb_parts[5].iov_base = 0; 9881 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9882 9883 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 9884 return xcb_ret; 9885 } 9886 9887 9888 /***************************************************************************** 9889 ** 9890 ** xcb_void_cookie_t xcb_poly_arc 9891 ** 9892 ** @param xcb_connection_t *c 9893 ** @param xcb_drawable_t drawable 9894 ** @param xcb_gcontext_t gc 9895 ** @param uint32_t arcs_len 9896 ** @param const xcb_arc_t *arcs 9897 ** @returns xcb_void_cookie_t 9898 ** 9899 *****************************************************************************/ 9900 9901 xcb_void_cookie_t 9902 xcb_poly_arc (xcb_connection_t *c /**< */, 9903 xcb_drawable_t drawable /**< */, 9904 xcb_gcontext_t gc /**< */, 9905 uint32_t arcs_len /**< */, 9906 const xcb_arc_t *arcs /**< */) 9907 { 9908 static const xcb_protocol_request_t xcb_req = { 9909 /* count */ 4, 9910 /* ext */ 0, 9911 /* opcode */ XCB_POLY_ARC, 9912 /* isvoid */ 1 9913 }; 9914 9915 struct iovec xcb_parts[6]; 9916 xcb_void_cookie_t xcb_ret; 9917 xcb_poly_arc_request_t xcb_out; 9918 9919 xcb_out.pad0 = 0; 9920 xcb_out.drawable = drawable; 9921 xcb_out.gc = gc; 9922 9923 xcb_parts[2].iov_base = (char *) &xcb_out; 9924 xcb_parts[2].iov_len = sizeof(xcb_out); 9925 xcb_parts[3].iov_base = 0; 9926 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 9927 /* xcb_arc_t arcs */ 9928 xcb_parts[4].iov_base = (char *) arcs; 9929 xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t); 9930 xcb_parts[5].iov_base = 0; 9931 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 9932 9933 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 9934 return xcb_ret; 9935 } 9936 9937 int 9938 xcb_fill_poly_sizeof (const void *_buffer /**< */, 9939 uint32_t points_len /**< */) 9940 { 9941 char *xcb_tmp = (char *)_buffer; 9942 unsigned int xcb_buffer_len = 0; 9943 unsigned int xcb_block_len = 0; 9944 unsigned int xcb_pad = 0; 9945 unsigned int xcb_align_to; 9946 9947 9948 xcb_block_len += sizeof(xcb_fill_poly_request_t); 9949 xcb_tmp += xcb_block_len; 9950 /* points */ 9951 xcb_block_len += points_len * sizeof(xcb_point_t); 9952 xcb_tmp += xcb_block_len; 9953 xcb_align_to = ALIGNOF(xcb_point_t); 9954 /* insert padding */ 9955 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 9956 xcb_buffer_len += xcb_block_len + xcb_pad; 9957 if (0 != xcb_pad) { 9958 xcb_tmp += xcb_pad; 9959 xcb_pad = 0; 9960 } 9961 xcb_block_len = 0; 9962 9963 return xcb_buffer_len; 9964 } 9965 9966 9967 /***************************************************************************** 9968 ** 9969 ** xcb_void_cookie_t xcb_fill_poly_checked 9970 ** 9971 ** @param xcb_connection_t *c 9972 ** @param xcb_drawable_t drawable 9973 ** @param xcb_gcontext_t gc 9974 ** @param uint8_t shape 9975 ** @param uint8_t coordinate_mode 9976 ** @param uint32_t points_len 9977 ** @param const xcb_point_t *points 9978 ** @returns xcb_void_cookie_t 9979 ** 9980 *****************************************************************************/ 9981 9982 xcb_void_cookie_t 9983 xcb_fill_poly_checked (xcb_connection_t *c /**< */, 9984 xcb_drawable_t drawable /**< */, 9985 xcb_gcontext_t gc /**< */, 9986 uint8_t shape /**< */, 9987 uint8_t coordinate_mode /**< */, 9988 uint32_t points_len /**< */, 9989 const xcb_point_t *points /**< */) 9990 { 9991 static const xcb_protocol_request_t xcb_req = { 9992 /* count */ 4, 9993 /* ext */ 0, 9994 /* opcode */ XCB_FILL_POLY, 9995 /* isvoid */ 1 9996 }; 9997 9998 struct iovec xcb_parts[6]; 9999 xcb_void_cookie_t xcb_ret; 10000 xcb_fill_poly_request_t xcb_out; 10001 10002 xcb_out.pad0 = 0; 10003 xcb_out.drawable = drawable; 10004 xcb_out.gc = gc; 10005 xcb_out.shape = shape; 10006 xcb_out.coordinate_mode = coordinate_mode; 10007 memset(xcb_out.pad1, 0, 2); 10008 10009 xcb_parts[2].iov_base = (char *) &xcb_out; 10010 xcb_parts[2].iov_len = sizeof(xcb_out); 10011 xcb_parts[3].iov_base = 0; 10012 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10013 /* xcb_point_t points */ 10014 xcb_parts[4].iov_base = (char *) points; 10015 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 10016 xcb_parts[5].iov_base = 0; 10017 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10018 10019 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10020 return xcb_ret; 10021 } 10022 10023 10024 /***************************************************************************** 10025 ** 10026 ** xcb_void_cookie_t xcb_fill_poly 10027 ** 10028 ** @param xcb_connection_t *c 10029 ** @param xcb_drawable_t drawable 10030 ** @param xcb_gcontext_t gc 10031 ** @param uint8_t shape 10032 ** @param uint8_t coordinate_mode 10033 ** @param uint32_t points_len 10034 ** @param const xcb_point_t *points 10035 ** @returns xcb_void_cookie_t 10036 ** 10037 *****************************************************************************/ 10038 10039 xcb_void_cookie_t 10040 xcb_fill_poly (xcb_connection_t *c /**< */, 10041 xcb_drawable_t drawable /**< */, 10042 xcb_gcontext_t gc /**< */, 10043 uint8_t shape /**< */, 10044 uint8_t coordinate_mode /**< */, 10045 uint32_t points_len /**< */, 10046 const xcb_point_t *points /**< */) 10047 { 10048 static const xcb_protocol_request_t xcb_req = { 10049 /* count */ 4, 10050 /* ext */ 0, 10051 /* opcode */ XCB_FILL_POLY, 10052 /* isvoid */ 1 10053 }; 10054 10055 struct iovec xcb_parts[6]; 10056 xcb_void_cookie_t xcb_ret; 10057 xcb_fill_poly_request_t xcb_out; 10058 10059 xcb_out.pad0 = 0; 10060 xcb_out.drawable = drawable; 10061 xcb_out.gc = gc; 10062 xcb_out.shape = shape; 10063 xcb_out.coordinate_mode = coordinate_mode; 10064 memset(xcb_out.pad1, 0, 2); 10065 10066 xcb_parts[2].iov_base = (char *) &xcb_out; 10067 xcb_parts[2].iov_len = sizeof(xcb_out); 10068 xcb_parts[3].iov_base = 0; 10069 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10070 /* xcb_point_t points */ 10071 xcb_parts[4].iov_base = (char *) points; 10072 xcb_parts[4].iov_len = points_len * sizeof(xcb_point_t); 10073 xcb_parts[5].iov_base = 0; 10074 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10075 10076 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10077 return xcb_ret; 10078 } 10079 10080 int 10081 xcb_poly_fill_rectangle_sizeof (const void *_buffer /**< */, 10082 uint32_t rectangles_len /**< */) 10083 { 10084 char *xcb_tmp = (char *)_buffer; 10085 unsigned int xcb_buffer_len = 0; 10086 unsigned int xcb_block_len = 0; 10087 unsigned int xcb_pad = 0; 10088 unsigned int xcb_align_to; 10089 10090 10091 xcb_block_len += sizeof(xcb_poly_fill_rectangle_request_t); 10092 xcb_tmp += xcb_block_len; 10093 /* rectangles */ 10094 xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); 10095 xcb_tmp += xcb_block_len; 10096 xcb_align_to = ALIGNOF(xcb_rectangle_t); 10097 /* insert padding */ 10098 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10099 xcb_buffer_len += xcb_block_len + xcb_pad; 10100 if (0 != xcb_pad) { 10101 xcb_tmp += xcb_pad; 10102 xcb_pad = 0; 10103 } 10104 xcb_block_len = 0; 10105 10106 return xcb_buffer_len; 10107 } 10108 10109 10110 /***************************************************************************** 10111 ** 10112 ** xcb_void_cookie_t xcb_poly_fill_rectangle_checked 10113 ** 10114 ** @param xcb_connection_t *c 10115 ** @param xcb_drawable_t drawable 10116 ** @param xcb_gcontext_t gc 10117 ** @param uint32_t rectangles_len 10118 ** @param const xcb_rectangle_t *rectangles 10119 ** @returns xcb_void_cookie_t 10120 ** 10121 *****************************************************************************/ 10122 10123 xcb_void_cookie_t 10124 xcb_poly_fill_rectangle_checked (xcb_connection_t *c /**< */, 10125 xcb_drawable_t drawable /**< */, 10126 xcb_gcontext_t gc /**< */, 10127 uint32_t rectangles_len /**< */, 10128 const xcb_rectangle_t *rectangles /**< */) 10129 { 10130 static const xcb_protocol_request_t xcb_req = { 10131 /* count */ 4, 10132 /* ext */ 0, 10133 /* opcode */ XCB_POLY_FILL_RECTANGLE, 10134 /* isvoid */ 1 10135 }; 10136 10137 struct iovec xcb_parts[6]; 10138 xcb_void_cookie_t xcb_ret; 10139 xcb_poly_fill_rectangle_request_t xcb_out; 10140 10141 xcb_out.pad0 = 0; 10142 xcb_out.drawable = drawable; 10143 xcb_out.gc = gc; 10144 10145 xcb_parts[2].iov_base = (char *) &xcb_out; 10146 xcb_parts[2].iov_len = sizeof(xcb_out); 10147 xcb_parts[3].iov_base = 0; 10148 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10149 /* xcb_rectangle_t rectangles */ 10150 xcb_parts[4].iov_base = (char *) rectangles; 10151 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 10152 xcb_parts[5].iov_base = 0; 10153 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10154 10155 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10156 return xcb_ret; 10157 } 10158 10159 10160 /***************************************************************************** 10161 ** 10162 ** xcb_void_cookie_t xcb_poly_fill_rectangle 10163 ** 10164 ** @param xcb_connection_t *c 10165 ** @param xcb_drawable_t drawable 10166 ** @param xcb_gcontext_t gc 10167 ** @param uint32_t rectangles_len 10168 ** @param const xcb_rectangle_t *rectangles 10169 ** @returns xcb_void_cookie_t 10170 ** 10171 *****************************************************************************/ 10172 10173 xcb_void_cookie_t 10174 xcb_poly_fill_rectangle (xcb_connection_t *c /**< */, 10175 xcb_drawable_t drawable /**< */, 10176 xcb_gcontext_t gc /**< */, 10177 uint32_t rectangles_len /**< */, 10178 const xcb_rectangle_t *rectangles /**< */) 10179 { 10180 static const xcb_protocol_request_t xcb_req = { 10181 /* count */ 4, 10182 /* ext */ 0, 10183 /* opcode */ XCB_POLY_FILL_RECTANGLE, 10184 /* isvoid */ 1 10185 }; 10186 10187 struct iovec xcb_parts[6]; 10188 xcb_void_cookie_t xcb_ret; 10189 xcb_poly_fill_rectangle_request_t xcb_out; 10190 10191 xcb_out.pad0 = 0; 10192 xcb_out.drawable = drawable; 10193 xcb_out.gc = gc; 10194 10195 xcb_parts[2].iov_base = (char *) &xcb_out; 10196 xcb_parts[2].iov_len = sizeof(xcb_out); 10197 xcb_parts[3].iov_base = 0; 10198 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10199 /* xcb_rectangle_t rectangles */ 10200 xcb_parts[4].iov_base = (char *) rectangles; 10201 xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); 10202 xcb_parts[5].iov_base = 0; 10203 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10204 10205 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10206 return xcb_ret; 10207 } 10208 10209 int 10210 xcb_poly_fill_arc_sizeof (const void *_buffer /**< */, 10211 uint32_t arcs_len /**< */) 10212 { 10213 char *xcb_tmp = (char *)_buffer; 10214 unsigned int xcb_buffer_len = 0; 10215 unsigned int xcb_block_len = 0; 10216 unsigned int xcb_pad = 0; 10217 unsigned int xcb_align_to; 10218 10219 10220 xcb_block_len += sizeof(xcb_poly_fill_arc_request_t); 10221 xcb_tmp += xcb_block_len; 10222 /* arcs */ 10223 xcb_block_len += arcs_len * sizeof(xcb_arc_t); 10224 xcb_tmp += xcb_block_len; 10225 xcb_align_to = ALIGNOF(xcb_arc_t); 10226 /* insert padding */ 10227 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10228 xcb_buffer_len += xcb_block_len + xcb_pad; 10229 if (0 != xcb_pad) { 10230 xcb_tmp += xcb_pad; 10231 xcb_pad = 0; 10232 } 10233 xcb_block_len = 0; 10234 10235 return xcb_buffer_len; 10236 } 10237 10238 10239 /***************************************************************************** 10240 ** 10241 ** xcb_void_cookie_t xcb_poly_fill_arc_checked 10242 ** 10243 ** @param xcb_connection_t *c 10244 ** @param xcb_drawable_t drawable 10245 ** @param xcb_gcontext_t gc 10246 ** @param uint32_t arcs_len 10247 ** @param const xcb_arc_t *arcs 10248 ** @returns xcb_void_cookie_t 10249 ** 10250 *****************************************************************************/ 10251 10252 xcb_void_cookie_t 10253 xcb_poly_fill_arc_checked (xcb_connection_t *c /**< */, 10254 xcb_drawable_t drawable /**< */, 10255 xcb_gcontext_t gc /**< */, 10256 uint32_t arcs_len /**< */, 10257 const xcb_arc_t *arcs /**< */) 10258 { 10259 static const xcb_protocol_request_t xcb_req = { 10260 /* count */ 4, 10261 /* ext */ 0, 10262 /* opcode */ XCB_POLY_FILL_ARC, 10263 /* isvoid */ 1 10264 }; 10265 10266 struct iovec xcb_parts[6]; 10267 xcb_void_cookie_t xcb_ret; 10268 xcb_poly_fill_arc_request_t xcb_out; 10269 10270 xcb_out.pad0 = 0; 10271 xcb_out.drawable = drawable; 10272 xcb_out.gc = gc; 10273 10274 xcb_parts[2].iov_base = (char *) &xcb_out; 10275 xcb_parts[2].iov_len = sizeof(xcb_out); 10276 xcb_parts[3].iov_base = 0; 10277 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10278 /* xcb_arc_t arcs */ 10279 xcb_parts[4].iov_base = (char *) arcs; 10280 xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t); 10281 xcb_parts[5].iov_base = 0; 10282 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10283 10284 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10285 return xcb_ret; 10286 } 10287 10288 10289 /***************************************************************************** 10290 ** 10291 ** xcb_void_cookie_t xcb_poly_fill_arc 10292 ** 10293 ** @param xcb_connection_t *c 10294 ** @param xcb_drawable_t drawable 10295 ** @param xcb_gcontext_t gc 10296 ** @param uint32_t arcs_len 10297 ** @param const xcb_arc_t *arcs 10298 ** @returns xcb_void_cookie_t 10299 ** 10300 *****************************************************************************/ 10301 10302 xcb_void_cookie_t 10303 xcb_poly_fill_arc (xcb_connection_t *c /**< */, 10304 xcb_drawable_t drawable /**< */, 10305 xcb_gcontext_t gc /**< */, 10306 uint32_t arcs_len /**< */, 10307 const xcb_arc_t *arcs /**< */) 10308 { 10309 static const xcb_protocol_request_t xcb_req = { 10310 /* count */ 4, 10311 /* ext */ 0, 10312 /* opcode */ XCB_POLY_FILL_ARC, 10313 /* isvoid */ 1 10314 }; 10315 10316 struct iovec xcb_parts[6]; 10317 xcb_void_cookie_t xcb_ret; 10318 xcb_poly_fill_arc_request_t xcb_out; 10319 10320 xcb_out.pad0 = 0; 10321 xcb_out.drawable = drawable; 10322 xcb_out.gc = gc; 10323 10324 xcb_parts[2].iov_base = (char *) &xcb_out; 10325 xcb_parts[2].iov_len = sizeof(xcb_out); 10326 xcb_parts[3].iov_base = 0; 10327 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10328 /* xcb_arc_t arcs */ 10329 xcb_parts[4].iov_base = (char *) arcs; 10330 xcb_parts[4].iov_len = arcs_len * sizeof(xcb_arc_t); 10331 xcb_parts[5].iov_base = 0; 10332 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10333 10334 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10335 return xcb_ret; 10336 } 10337 10338 int 10339 xcb_put_image_sizeof (const void *_buffer /**< */, 10340 uint32_t data_len /**< */) 10341 { 10342 char *xcb_tmp = (char *)_buffer; 10343 unsigned int xcb_buffer_len = 0; 10344 unsigned int xcb_block_len = 0; 10345 unsigned int xcb_pad = 0; 10346 unsigned int xcb_align_to; 10347 10348 10349 xcb_block_len += sizeof(xcb_put_image_request_t); 10350 xcb_tmp += xcb_block_len; 10351 /* data */ 10352 xcb_block_len += data_len * sizeof(uint8_t); 10353 xcb_tmp += xcb_block_len; 10354 xcb_align_to = ALIGNOF(uint8_t); 10355 /* insert padding */ 10356 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10357 xcb_buffer_len += xcb_block_len + xcb_pad; 10358 if (0 != xcb_pad) { 10359 xcb_tmp += xcb_pad; 10360 xcb_pad = 0; 10361 } 10362 xcb_block_len = 0; 10363 10364 return xcb_buffer_len; 10365 } 10366 10367 10368 /***************************************************************************** 10369 ** 10370 ** xcb_void_cookie_t xcb_put_image_checked 10371 ** 10372 ** @param xcb_connection_t *c 10373 ** @param uint8_t format 10374 ** @param xcb_drawable_t drawable 10375 ** @param xcb_gcontext_t gc 10376 ** @param uint16_t width 10377 ** @param uint16_t height 10378 ** @param int16_t dst_x 10379 ** @param int16_t dst_y 10380 ** @param uint8_t left_pad 10381 ** @param uint8_t depth 10382 ** @param uint32_t data_len 10383 ** @param const uint8_t *data 10384 ** @returns xcb_void_cookie_t 10385 ** 10386 *****************************************************************************/ 10387 10388 xcb_void_cookie_t 10389 xcb_put_image_checked (xcb_connection_t *c /**< */, 10390 uint8_t format /**< */, 10391 xcb_drawable_t drawable /**< */, 10392 xcb_gcontext_t gc /**< */, 10393 uint16_t width /**< */, 10394 uint16_t height /**< */, 10395 int16_t dst_x /**< */, 10396 int16_t dst_y /**< */, 10397 uint8_t left_pad /**< */, 10398 uint8_t depth /**< */, 10399 uint32_t data_len /**< */, 10400 const uint8_t *data /**< */) 10401 { 10402 static const xcb_protocol_request_t xcb_req = { 10403 /* count */ 4, 10404 /* ext */ 0, 10405 /* opcode */ XCB_PUT_IMAGE, 10406 /* isvoid */ 1 10407 }; 10408 10409 struct iovec xcb_parts[6]; 10410 xcb_void_cookie_t xcb_ret; 10411 xcb_put_image_request_t xcb_out; 10412 10413 xcb_out.format = format; 10414 xcb_out.drawable = drawable; 10415 xcb_out.gc = gc; 10416 xcb_out.width = width; 10417 xcb_out.height = height; 10418 xcb_out.dst_x = dst_x; 10419 xcb_out.dst_y = dst_y; 10420 xcb_out.left_pad = left_pad; 10421 xcb_out.depth = depth; 10422 memset(xcb_out.pad0, 0, 2); 10423 10424 xcb_parts[2].iov_base = (char *) &xcb_out; 10425 xcb_parts[2].iov_len = sizeof(xcb_out); 10426 xcb_parts[3].iov_base = 0; 10427 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10428 /* uint8_t data */ 10429 xcb_parts[4].iov_base = (char *) data; 10430 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 10431 xcb_parts[5].iov_base = 0; 10432 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10433 10434 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10435 return xcb_ret; 10436 } 10437 10438 10439 /***************************************************************************** 10440 ** 10441 ** xcb_void_cookie_t xcb_put_image 10442 ** 10443 ** @param xcb_connection_t *c 10444 ** @param uint8_t format 10445 ** @param xcb_drawable_t drawable 10446 ** @param xcb_gcontext_t gc 10447 ** @param uint16_t width 10448 ** @param uint16_t height 10449 ** @param int16_t dst_x 10450 ** @param int16_t dst_y 10451 ** @param uint8_t left_pad 10452 ** @param uint8_t depth 10453 ** @param uint32_t data_len 10454 ** @param const uint8_t *data 10455 ** @returns xcb_void_cookie_t 10456 ** 10457 *****************************************************************************/ 10458 10459 xcb_void_cookie_t 10460 xcb_put_image (xcb_connection_t *c /**< */, 10461 uint8_t format /**< */, 10462 xcb_drawable_t drawable /**< */, 10463 xcb_gcontext_t gc /**< */, 10464 uint16_t width /**< */, 10465 uint16_t height /**< */, 10466 int16_t dst_x /**< */, 10467 int16_t dst_y /**< */, 10468 uint8_t left_pad /**< */, 10469 uint8_t depth /**< */, 10470 uint32_t data_len /**< */, 10471 const uint8_t *data /**< */) 10472 { 10473 static const xcb_protocol_request_t xcb_req = { 10474 /* count */ 4, 10475 /* ext */ 0, 10476 /* opcode */ XCB_PUT_IMAGE, 10477 /* isvoid */ 1 10478 }; 10479 10480 struct iovec xcb_parts[6]; 10481 xcb_void_cookie_t xcb_ret; 10482 xcb_put_image_request_t xcb_out; 10483 10484 xcb_out.format = format; 10485 xcb_out.drawable = drawable; 10486 xcb_out.gc = gc; 10487 xcb_out.width = width; 10488 xcb_out.height = height; 10489 xcb_out.dst_x = dst_x; 10490 xcb_out.dst_y = dst_y; 10491 xcb_out.left_pad = left_pad; 10492 xcb_out.depth = depth; 10493 memset(xcb_out.pad0, 0, 2); 10494 10495 xcb_parts[2].iov_base = (char *) &xcb_out; 10496 xcb_parts[2].iov_len = sizeof(xcb_out); 10497 xcb_parts[3].iov_base = 0; 10498 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10499 /* uint8_t data */ 10500 xcb_parts[4].iov_base = (char *) data; 10501 xcb_parts[4].iov_len = data_len * sizeof(uint8_t); 10502 xcb_parts[5].iov_base = 0; 10503 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10504 10505 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10506 return xcb_ret; 10507 } 10508 10509 int 10510 xcb_get_image_sizeof (const void *_buffer /**< */) 10511 { 10512 char *xcb_tmp = (char *)_buffer; 10513 const xcb_get_image_reply_t *_aux = (xcb_get_image_reply_t *)_buffer; 10514 unsigned int xcb_buffer_len = 0; 10515 unsigned int xcb_block_len = 0; 10516 unsigned int xcb_pad = 0; 10517 unsigned int xcb_align_to; 10518 10519 10520 xcb_block_len += sizeof(xcb_get_image_reply_t); 10521 xcb_tmp += xcb_block_len; 10522 /* data */ 10523 xcb_block_len += (_aux->length * 4) * sizeof(uint8_t); 10524 xcb_tmp += xcb_block_len; 10525 xcb_align_to = ALIGNOF(uint8_t); 10526 /* insert padding */ 10527 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10528 xcb_buffer_len += xcb_block_len + xcb_pad; 10529 if (0 != xcb_pad) { 10530 xcb_tmp += xcb_pad; 10531 xcb_pad = 0; 10532 } 10533 xcb_block_len = 0; 10534 10535 return xcb_buffer_len; 10536 } 10537 10538 10539 /***************************************************************************** 10540 ** 10541 ** xcb_get_image_cookie_t xcb_get_image 10542 ** 10543 ** @param xcb_connection_t *c 10544 ** @param uint8_t format 10545 ** @param xcb_drawable_t drawable 10546 ** @param int16_t x 10547 ** @param int16_t y 10548 ** @param uint16_t width 10549 ** @param uint16_t height 10550 ** @param uint32_t plane_mask 10551 ** @returns xcb_get_image_cookie_t 10552 ** 10553 *****************************************************************************/ 10554 10555 xcb_get_image_cookie_t 10556 xcb_get_image (xcb_connection_t *c /**< */, 10557 uint8_t format /**< */, 10558 xcb_drawable_t drawable /**< */, 10559 int16_t x /**< */, 10560 int16_t y /**< */, 10561 uint16_t width /**< */, 10562 uint16_t height /**< */, 10563 uint32_t plane_mask /**< */) 10564 { 10565 static const xcb_protocol_request_t xcb_req = { 10566 /* count */ 2, 10567 /* ext */ 0, 10568 /* opcode */ XCB_GET_IMAGE, 10569 /* isvoid */ 0 10570 }; 10571 10572 struct iovec xcb_parts[4]; 10573 xcb_get_image_cookie_t xcb_ret; 10574 xcb_get_image_request_t xcb_out; 10575 10576 xcb_out.format = format; 10577 xcb_out.drawable = drawable; 10578 xcb_out.x = x; 10579 xcb_out.y = y; 10580 xcb_out.width = width; 10581 xcb_out.height = height; 10582 xcb_out.plane_mask = plane_mask; 10583 10584 xcb_parts[2].iov_base = (char *) &xcb_out; 10585 xcb_parts[2].iov_len = sizeof(xcb_out); 10586 xcb_parts[3].iov_base = 0; 10587 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10588 10589 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10590 return xcb_ret; 10591 } 10592 10593 10594 /***************************************************************************** 10595 ** 10596 ** xcb_get_image_cookie_t xcb_get_image_unchecked 10597 ** 10598 ** @param xcb_connection_t *c 10599 ** @param uint8_t format 10600 ** @param xcb_drawable_t drawable 10601 ** @param int16_t x 10602 ** @param int16_t y 10603 ** @param uint16_t width 10604 ** @param uint16_t height 10605 ** @param uint32_t plane_mask 10606 ** @returns xcb_get_image_cookie_t 10607 ** 10608 *****************************************************************************/ 10609 10610 xcb_get_image_cookie_t 10611 xcb_get_image_unchecked (xcb_connection_t *c /**< */, 10612 uint8_t format /**< */, 10613 xcb_drawable_t drawable /**< */, 10614 int16_t x /**< */, 10615 int16_t y /**< */, 10616 uint16_t width /**< */, 10617 uint16_t height /**< */, 10618 uint32_t plane_mask /**< */) 10619 { 10620 static const xcb_protocol_request_t xcb_req = { 10621 /* count */ 2, 10622 /* ext */ 0, 10623 /* opcode */ XCB_GET_IMAGE, 10624 /* isvoid */ 0 10625 }; 10626 10627 struct iovec xcb_parts[4]; 10628 xcb_get_image_cookie_t xcb_ret; 10629 xcb_get_image_request_t xcb_out; 10630 10631 xcb_out.format = format; 10632 xcb_out.drawable = drawable; 10633 xcb_out.x = x; 10634 xcb_out.y = y; 10635 xcb_out.width = width; 10636 xcb_out.height = height; 10637 xcb_out.plane_mask = plane_mask; 10638 10639 xcb_parts[2].iov_base = (char *) &xcb_out; 10640 xcb_parts[2].iov_len = sizeof(xcb_out); 10641 xcb_parts[3].iov_base = 0; 10642 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10643 10644 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10645 return xcb_ret; 10646 } 10647 10648 10649 /***************************************************************************** 10650 ** 10651 ** uint8_t * xcb_get_image_data 10652 ** 10653 ** @param const xcb_get_image_reply_t *R 10654 ** @returns uint8_t * 10655 ** 10656 *****************************************************************************/ 10657 10658 uint8_t * 10659 xcb_get_image_data (const xcb_get_image_reply_t *R /**< */) 10660 { 10661 return (uint8_t *) (R + 1); 10662 } 10663 10664 10665 /***************************************************************************** 10666 ** 10667 ** int xcb_get_image_data_length 10668 ** 10669 ** @param const xcb_get_image_reply_t *R 10670 ** @returns int 10671 ** 10672 *****************************************************************************/ 10673 10674 int 10675 xcb_get_image_data_length (const xcb_get_image_reply_t *R /**< */) 10676 { 10677 return (R->length * 4); 10678 } 10679 10680 10681 /***************************************************************************** 10682 ** 10683 ** xcb_generic_iterator_t xcb_get_image_data_end 10684 ** 10685 ** @param const xcb_get_image_reply_t *R 10686 ** @returns xcb_generic_iterator_t 10687 ** 10688 *****************************************************************************/ 10689 10690 xcb_generic_iterator_t 10691 xcb_get_image_data_end (const xcb_get_image_reply_t *R /**< */) 10692 { 10693 xcb_generic_iterator_t i; 10694 i.data = ((uint8_t *) (R + 1)) + ((R->length * 4)); 10695 i.rem = 0; 10696 i.index = (char *) i.data - (char *) R; 10697 return i; 10698 } 10699 10700 10701 /***************************************************************************** 10702 ** 10703 ** xcb_get_image_reply_t * xcb_get_image_reply 10704 ** 10705 ** @param xcb_connection_t *c 10706 ** @param xcb_get_image_cookie_t cookie 10707 ** @param xcb_generic_error_t **e 10708 ** @returns xcb_get_image_reply_t * 10709 ** 10710 *****************************************************************************/ 10711 10712 xcb_get_image_reply_t * 10713 xcb_get_image_reply (xcb_connection_t *c /**< */, 10714 xcb_get_image_cookie_t cookie /**< */, 10715 xcb_generic_error_t **e /**< */) 10716 { 10717 return (xcb_get_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 10718 } 10719 10720 int 10721 xcb_poly_text_8_sizeof (const void *_buffer /**< */, 10722 uint32_t items_len /**< */) 10723 { 10724 char *xcb_tmp = (char *)_buffer; 10725 unsigned int xcb_buffer_len = 0; 10726 unsigned int xcb_block_len = 0; 10727 unsigned int xcb_pad = 0; 10728 unsigned int xcb_align_to; 10729 10730 10731 xcb_block_len += sizeof(xcb_poly_text_8_request_t); 10732 xcb_tmp += xcb_block_len; 10733 /* items */ 10734 xcb_block_len += items_len * sizeof(uint8_t); 10735 xcb_tmp += xcb_block_len; 10736 xcb_align_to = ALIGNOF(uint8_t); 10737 /* insert padding */ 10738 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10739 xcb_buffer_len += xcb_block_len + xcb_pad; 10740 if (0 != xcb_pad) { 10741 xcb_tmp += xcb_pad; 10742 xcb_pad = 0; 10743 } 10744 xcb_block_len = 0; 10745 10746 return xcb_buffer_len; 10747 } 10748 10749 10750 /***************************************************************************** 10751 ** 10752 ** xcb_void_cookie_t xcb_poly_text_8_checked 10753 ** 10754 ** @param xcb_connection_t *c 10755 ** @param xcb_drawable_t drawable 10756 ** @param xcb_gcontext_t gc 10757 ** @param int16_t x 10758 ** @param int16_t y 10759 ** @param uint32_t items_len 10760 ** @param const uint8_t *items 10761 ** @returns xcb_void_cookie_t 10762 ** 10763 *****************************************************************************/ 10764 10765 xcb_void_cookie_t 10766 xcb_poly_text_8_checked (xcb_connection_t *c /**< */, 10767 xcb_drawable_t drawable /**< */, 10768 xcb_gcontext_t gc /**< */, 10769 int16_t x /**< */, 10770 int16_t y /**< */, 10771 uint32_t items_len /**< */, 10772 const uint8_t *items /**< */) 10773 { 10774 static const xcb_protocol_request_t xcb_req = { 10775 /* count */ 4, 10776 /* ext */ 0, 10777 /* opcode */ XCB_POLY_TEXT_8, 10778 /* isvoid */ 1 10779 }; 10780 10781 struct iovec xcb_parts[6]; 10782 xcb_void_cookie_t xcb_ret; 10783 xcb_poly_text_8_request_t xcb_out; 10784 10785 xcb_out.pad0 = 0; 10786 xcb_out.drawable = drawable; 10787 xcb_out.gc = gc; 10788 xcb_out.x = x; 10789 xcb_out.y = y; 10790 10791 xcb_parts[2].iov_base = (char *) &xcb_out; 10792 xcb_parts[2].iov_len = sizeof(xcb_out); 10793 xcb_parts[3].iov_base = 0; 10794 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10795 /* uint8_t items */ 10796 xcb_parts[4].iov_base = (char *) items; 10797 xcb_parts[4].iov_len = items_len * sizeof(uint8_t); 10798 xcb_parts[5].iov_base = 0; 10799 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10800 10801 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10802 return xcb_ret; 10803 } 10804 10805 10806 /***************************************************************************** 10807 ** 10808 ** xcb_void_cookie_t xcb_poly_text_8 10809 ** 10810 ** @param xcb_connection_t *c 10811 ** @param xcb_drawable_t drawable 10812 ** @param xcb_gcontext_t gc 10813 ** @param int16_t x 10814 ** @param int16_t y 10815 ** @param uint32_t items_len 10816 ** @param const uint8_t *items 10817 ** @returns xcb_void_cookie_t 10818 ** 10819 *****************************************************************************/ 10820 10821 xcb_void_cookie_t 10822 xcb_poly_text_8 (xcb_connection_t *c /**< */, 10823 xcb_drawable_t drawable /**< */, 10824 xcb_gcontext_t gc /**< */, 10825 int16_t x /**< */, 10826 int16_t y /**< */, 10827 uint32_t items_len /**< */, 10828 const uint8_t *items /**< */) 10829 { 10830 static const xcb_protocol_request_t xcb_req = { 10831 /* count */ 4, 10832 /* ext */ 0, 10833 /* opcode */ XCB_POLY_TEXT_8, 10834 /* isvoid */ 1 10835 }; 10836 10837 struct iovec xcb_parts[6]; 10838 xcb_void_cookie_t xcb_ret; 10839 xcb_poly_text_8_request_t xcb_out; 10840 10841 xcb_out.pad0 = 0; 10842 xcb_out.drawable = drawable; 10843 xcb_out.gc = gc; 10844 xcb_out.x = x; 10845 xcb_out.y = y; 10846 10847 xcb_parts[2].iov_base = (char *) &xcb_out; 10848 xcb_parts[2].iov_len = sizeof(xcb_out); 10849 xcb_parts[3].iov_base = 0; 10850 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10851 /* uint8_t items */ 10852 xcb_parts[4].iov_base = (char *) items; 10853 xcb_parts[4].iov_len = items_len * sizeof(uint8_t); 10854 xcb_parts[5].iov_base = 0; 10855 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10856 10857 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10858 return xcb_ret; 10859 } 10860 10861 int 10862 xcb_poly_text_16_sizeof (const void *_buffer /**< */, 10863 uint32_t items_len /**< */) 10864 { 10865 char *xcb_tmp = (char *)_buffer; 10866 unsigned int xcb_buffer_len = 0; 10867 unsigned int xcb_block_len = 0; 10868 unsigned int xcb_pad = 0; 10869 unsigned int xcb_align_to; 10870 10871 10872 xcb_block_len += sizeof(xcb_poly_text_16_request_t); 10873 xcb_tmp += xcb_block_len; 10874 /* items */ 10875 xcb_block_len += items_len * sizeof(uint8_t); 10876 xcb_tmp += xcb_block_len; 10877 xcb_align_to = ALIGNOF(uint8_t); 10878 /* insert padding */ 10879 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 10880 xcb_buffer_len += xcb_block_len + xcb_pad; 10881 if (0 != xcb_pad) { 10882 xcb_tmp += xcb_pad; 10883 xcb_pad = 0; 10884 } 10885 xcb_block_len = 0; 10886 10887 return xcb_buffer_len; 10888 } 10889 10890 10891 /***************************************************************************** 10892 ** 10893 ** xcb_void_cookie_t xcb_poly_text_16_checked 10894 ** 10895 ** @param xcb_connection_t *c 10896 ** @param xcb_drawable_t drawable 10897 ** @param xcb_gcontext_t gc 10898 ** @param int16_t x 10899 ** @param int16_t y 10900 ** @param uint32_t items_len 10901 ** @param const uint8_t *items 10902 ** @returns xcb_void_cookie_t 10903 ** 10904 *****************************************************************************/ 10905 10906 xcb_void_cookie_t 10907 xcb_poly_text_16_checked (xcb_connection_t *c /**< */, 10908 xcb_drawable_t drawable /**< */, 10909 xcb_gcontext_t gc /**< */, 10910 int16_t x /**< */, 10911 int16_t y /**< */, 10912 uint32_t items_len /**< */, 10913 const uint8_t *items /**< */) 10914 { 10915 static const xcb_protocol_request_t xcb_req = { 10916 /* count */ 4, 10917 /* ext */ 0, 10918 /* opcode */ XCB_POLY_TEXT_16, 10919 /* isvoid */ 1 10920 }; 10921 10922 struct iovec xcb_parts[6]; 10923 xcb_void_cookie_t xcb_ret; 10924 xcb_poly_text_16_request_t xcb_out; 10925 10926 xcb_out.pad0 = 0; 10927 xcb_out.drawable = drawable; 10928 xcb_out.gc = gc; 10929 xcb_out.x = x; 10930 xcb_out.y = y; 10931 10932 xcb_parts[2].iov_base = (char *) &xcb_out; 10933 xcb_parts[2].iov_len = sizeof(xcb_out); 10934 xcb_parts[3].iov_base = 0; 10935 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10936 /* uint8_t items */ 10937 xcb_parts[4].iov_base = (char *) items; 10938 xcb_parts[4].iov_len = items_len * sizeof(uint8_t); 10939 xcb_parts[5].iov_base = 0; 10940 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10941 10942 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 10943 return xcb_ret; 10944 } 10945 10946 10947 /***************************************************************************** 10948 ** 10949 ** xcb_void_cookie_t xcb_poly_text_16 10950 ** 10951 ** @param xcb_connection_t *c 10952 ** @param xcb_drawable_t drawable 10953 ** @param xcb_gcontext_t gc 10954 ** @param int16_t x 10955 ** @param int16_t y 10956 ** @param uint32_t items_len 10957 ** @param const uint8_t *items 10958 ** @returns xcb_void_cookie_t 10959 ** 10960 *****************************************************************************/ 10961 10962 xcb_void_cookie_t 10963 xcb_poly_text_16 (xcb_connection_t *c /**< */, 10964 xcb_drawable_t drawable /**< */, 10965 xcb_gcontext_t gc /**< */, 10966 int16_t x /**< */, 10967 int16_t y /**< */, 10968 uint32_t items_len /**< */, 10969 const uint8_t *items /**< */) 10970 { 10971 static const xcb_protocol_request_t xcb_req = { 10972 /* count */ 4, 10973 /* ext */ 0, 10974 /* opcode */ XCB_POLY_TEXT_16, 10975 /* isvoid */ 1 10976 }; 10977 10978 struct iovec xcb_parts[6]; 10979 xcb_void_cookie_t xcb_ret; 10980 xcb_poly_text_16_request_t xcb_out; 10981 10982 xcb_out.pad0 = 0; 10983 xcb_out.drawable = drawable; 10984 xcb_out.gc = gc; 10985 xcb_out.x = x; 10986 xcb_out.y = y; 10987 10988 xcb_parts[2].iov_base = (char *) &xcb_out; 10989 xcb_parts[2].iov_len = sizeof(xcb_out); 10990 xcb_parts[3].iov_base = 0; 10991 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 10992 /* uint8_t items */ 10993 xcb_parts[4].iov_base = (char *) items; 10994 xcb_parts[4].iov_len = items_len * sizeof(uint8_t); 10995 xcb_parts[5].iov_base = 0; 10996 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 10997 10998 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 10999 return xcb_ret; 11000 } 11001 11002 int 11003 xcb_image_text_8_sizeof (const void *_buffer /**< */) 11004 { 11005 char *xcb_tmp = (char *)_buffer; 11006 const xcb_image_text_8_request_t *_aux = (xcb_image_text_8_request_t *)_buffer; 11007 unsigned int xcb_buffer_len = 0; 11008 unsigned int xcb_block_len = 0; 11009 unsigned int xcb_pad = 0; 11010 unsigned int xcb_align_to; 11011 11012 11013 xcb_block_len += sizeof(xcb_image_text_8_request_t); 11014 xcb_tmp += xcb_block_len; 11015 /* string */ 11016 xcb_block_len += _aux->string_len * sizeof(char); 11017 xcb_tmp += xcb_block_len; 11018 xcb_align_to = ALIGNOF(char); 11019 /* insert padding */ 11020 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11021 xcb_buffer_len += xcb_block_len + xcb_pad; 11022 if (0 != xcb_pad) { 11023 xcb_tmp += xcb_pad; 11024 xcb_pad = 0; 11025 } 11026 xcb_block_len = 0; 11027 11028 return xcb_buffer_len; 11029 } 11030 11031 11032 /***************************************************************************** 11033 ** 11034 ** xcb_void_cookie_t xcb_image_text_8_checked 11035 ** 11036 ** @param xcb_connection_t *c 11037 ** @param uint8_t string_len 11038 ** @param xcb_drawable_t drawable 11039 ** @param xcb_gcontext_t gc 11040 ** @param int16_t x 11041 ** @param int16_t y 11042 ** @param const char *string 11043 ** @returns xcb_void_cookie_t 11044 ** 11045 *****************************************************************************/ 11046 11047 xcb_void_cookie_t 11048 xcb_image_text_8_checked (xcb_connection_t *c /**< */, 11049 uint8_t string_len /**< */, 11050 xcb_drawable_t drawable /**< */, 11051 xcb_gcontext_t gc /**< */, 11052 int16_t x /**< */, 11053 int16_t y /**< */, 11054 const char *string /**< */) 11055 { 11056 static const xcb_protocol_request_t xcb_req = { 11057 /* count */ 4, 11058 /* ext */ 0, 11059 /* opcode */ XCB_IMAGE_TEXT_8, 11060 /* isvoid */ 1 11061 }; 11062 11063 struct iovec xcb_parts[6]; 11064 xcb_void_cookie_t xcb_ret; 11065 xcb_image_text_8_request_t xcb_out; 11066 11067 xcb_out.string_len = string_len; 11068 xcb_out.drawable = drawable; 11069 xcb_out.gc = gc; 11070 xcb_out.x = x; 11071 xcb_out.y = y; 11072 11073 xcb_parts[2].iov_base = (char *) &xcb_out; 11074 xcb_parts[2].iov_len = sizeof(xcb_out); 11075 xcb_parts[3].iov_base = 0; 11076 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11077 /* char string */ 11078 xcb_parts[4].iov_base = (char *) string; 11079 xcb_parts[4].iov_len = string_len * sizeof(char); 11080 xcb_parts[5].iov_base = 0; 11081 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11082 11083 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11084 return xcb_ret; 11085 } 11086 11087 11088 /***************************************************************************** 11089 ** 11090 ** xcb_void_cookie_t xcb_image_text_8 11091 ** 11092 ** @param xcb_connection_t *c 11093 ** @param uint8_t string_len 11094 ** @param xcb_drawable_t drawable 11095 ** @param xcb_gcontext_t gc 11096 ** @param int16_t x 11097 ** @param int16_t y 11098 ** @param const char *string 11099 ** @returns xcb_void_cookie_t 11100 ** 11101 *****************************************************************************/ 11102 11103 xcb_void_cookie_t 11104 xcb_image_text_8 (xcb_connection_t *c /**< */, 11105 uint8_t string_len /**< */, 11106 xcb_drawable_t drawable /**< */, 11107 xcb_gcontext_t gc /**< */, 11108 int16_t x /**< */, 11109 int16_t y /**< */, 11110 const char *string /**< */) 11111 { 11112 static const xcb_protocol_request_t xcb_req = { 11113 /* count */ 4, 11114 /* ext */ 0, 11115 /* opcode */ XCB_IMAGE_TEXT_8, 11116 /* isvoid */ 1 11117 }; 11118 11119 struct iovec xcb_parts[6]; 11120 xcb_void_cookie_t xcb_ret; 11121 xcb_image_text_8_request_t xcb_out; 11122 11123 xcb_out.string_len = string_len; 11124 xcb_out.drawable = drawable; 11125 xcb_out.gc = gc; 11126 xcb_out.x = x; 11127 xcb_out.y = y; 11128 11129 xcb_parts[2].iov_base = (char *) &xcb_out; 11130 xcb_parts[2].iov_len = sizeof(xcb_out); 11131 xcb_parts[3].iov_base = 0; 11132 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11133 /* char string */ 11134 xcb_parts[4].iov_base = (char *) string; 11135 xcb_parts[4].iov_len = string_len * sizeof(char); 11136 xcb_parts[5].iov_base = 0; 11137 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11138 11139 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11140 return xcb_ret; 11141 } 11142 11143 int 11144 xcb_image_text_16_sizeof (const void *_buffer /**< */) 11145 { 11146 char *xcb_tmp = (char *)_buffer; 11147 const xcb_image_text_16_request_t *_aux = (xcb_image_text_16_request_t *)_buffer; 11148 unsigned int xcb_buffer_len = 0; 11149 unsigned int xcb_block_len = 0; 11150 unsigned int xcb_pad = 0; 11151 unsigned int xcb_align_to; 11152 11153 11154 xcb_block_len += sizeof(xcb_image_text_16_request_t); 11155 xcb_tmp += xcb_block_len; 11156 /* string */ 11157 xcb_block_len += _aux->string_len * sizeof(xcb_char2b_t); 11158 xcb_tmp += xcb_block_len; 11159 xcb_align_to = ALIGNOF(xcb_char2b_t); 11160 /* insert padding */ 11161 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11162 xcb_buffer_len += xcb_block_len + xcb_pad; 11163 if (0 != xcb_pad) { 11164 xcb_tmp += xcb_pad; 11165 xcb_pad = 0; 11166 } 11167 xcb_block_len = 0; 11168 11169 return xcb_buffer_len; 11170 } 11171 11172 11173 /***************************************************************************** 11174 ** 11175 ** xcb_void_cookie_t xcb_image_text_16_checked 11176 ** 11177 ** @param xcb_connection_t *c 11178 ** @param uint8_t string_len 11179 ** @param xcb_drawable_t drawable 11180 ** @param xcb_gcontext_t gc 11181 ** @param int16_t x 11182 ** @param int16_t y 11183 ** @param const xcb_char2b_t *string 11184 ** @returns xcb_void_cookie_t 11185 ** 11186 *****************************************************************************/ 11187 11188 xcb_void_cookie_t 11189 xcb_image_text_16_checked (xcb_connection_t *c /**< */, 11190 uint8_t string_len /**< */, 11191 xcb_drawable_t drawable /**< */, 11192 xcb_gcontext_t gc /**< */, 11193 int16_t x /**< */, 11194 int16_t y /**< */, 11195 const xcb_char2b_t *string /**< */) 11196 { 11197 static const xcb_protocol_request_t xcb_req = { 11198 /* count */ 4, 11199 /* ext */ 0, 11200 /* opcode */ XCB_IMAGE_TEXT_16, 11201 /* isvoid */ 1 11202 }; 11203 11204 struct iovec xcb_parts[6]; 11205 xcb_void_cookie_t xcb_ret; 11206 xcb_image_text_16_request_t xcb_out; 11207 11208 xcb_out.string_len = string_len; 11209 xcb_out.drawable = drawable; 11210 xcb_out.gc = gc; 11211 xcb_out.x = x; 11212 xcb_out.y = y; 11213 11214 xcb_parts[2].iov_base = (char *) &xcb_out; 11215 xcb_parts[2].iov_len = sizeof(xcb_out); 11216 xcb_parts[3].iov_base = 0; 11217 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11218 /* xcb_char2b_t string */ 11219 xcb_parts[4].iov_base = (char *) string; 11220 xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t); 11221 xcb_parts[5].iov_base = 0; 11222 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11223 11224 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11225 return xcb_ret; 11226 } 11227 11228 11229 /***************************************************************************** 11230 ** 11231 ** xcb_void_cookie_t xcb_image_text_16 11232 ** 11233 ** @param xcb_connection_t *c 11234 ** @param uint8_t string_len 11235 ** @param xcb_drawable_t drawable 11236 ** @param xcb_gcontext_t gc 11237 ** @param int16_t x 11238 ** @param int16_t y 11239 ** @param const xcb_char2b_t *string 11240 ** @returns xcb_void_cookie_t 11241 ** 11242 *****************************************************************************/ 11243 11244 xcb_void_cookie_t 11245 xcb_image_text_16 (xcb_connection_t *c /**< */, 11246 uint8_t string_len /**< */, 11247 xcb_drawable_t drawable /**< */, 11248 xcb_gcontext_t gc /**< */, 11249 int16_t x /**< */, 11250 int16_t y /**< */, 11251 const xcb_char2b_t *string /**< */) 11252 { 11253 static const xcb_protocol_request_t xcb_req = { 11254 /* count */ 4, 11255 /* ext */ 0, 11256 /* opcode */ XCB_IMAGE_TEXT_16, 11257 /* isvoid */ 1 11258 }; 11259 11260 struct iovec xcb_parts[6]; 11261 xcb_void_cookie_t xcb_ret; 11262 xcb_image_text_16_request_t xcb_out; 11263 11264 xcb_out.string_len = string_len; 11265 xcb_out.drawable = drawable; 11266 xcb_out.gc = gc; 11267 xcb_out.x = x; 11268 xcb_out.y = y; 11269 11270 xcb_parts[2].iov_base = (char *) &xcb_out; 11271 xcb_parts[2].iov_len = sizeof(xcb_out); 11272 xcb_parts[3].iov_base = 0; 11273 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11274 /* xcb_char2b_t string */ 11275 xcb_parts[4].iov_base = (char *) string; 11276 xcb_parts[4].iov_len = string_len * sizeof(xcb_char2b_t); 11277 xcb_parts[5].iov_base = 0; 11278 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 11279 11280 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11281 return xcb_ret; 11282 } 11283 11284 11285 /***************************************************************************** 11286 ** 11287 ** xcb_void_cookie_t xcb_create_colormap_checked 11288 ** 11289 ** @param xcb_connection_t *c 11290 ** @param uint8_t alloc 11291 ** @param xcb_colormap_t mid 11292 ** @param xcb_window_t window 11293 ** @param xcb_visualid_t visual 11294 ** @returns xcb_void_cookie_t 11295 ** 11296 *****************************************************************************/ 11297 11298 xcb_void_cookie_t 11299 xcb_create_colormap_checked (xcb_connection_t *c /**< */, 11300 uint8_t alloc /**< */, 11301 xcb_colormap_t mid /**< */, 11302 xcb_window_t window /**< */, 11303 xcb_visualid_t visual /**< */) 11304 { 11305 static const xcb_protocol_request_t xcb_req = { 11306 /* count */ 2, 11307 /* ext */ 0, 11308 /* opcode */ XCB_CREATE_COLORMAP, 11309 /* isvoid */ 1 11310 }; 11311 11312 struct iovec xcb_parts[4]; 11313 xcb_void_cookie_t xcb_ret; 11314 xcb_create_colormap_request_t xcb_out; 11315 11316 xcb_out.alloc = alloc; 11317 xcb_out.mid = mid; 11318 xcb_out.window = window; 11319 xcb_out.visual = visual; 11320 11321 xcb_parts[2].iov_base = (char *) &xcb_out; 11322 xcb_parts[2].iov_len = sizeof(xcb_out); 11323 xcb_parts[3].iov_base = 0; 11324 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11325 11326 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11327 return xcb_ret; 11328 } 11329 11330 11331 /***************************************************************************** 11332 ** 11333 ** xcb_void_cookie_t xcb_create_colormap 11334 ** 11335 ** @param xcb_connection_t *c 11336 ** @param uint8_t alloc 11337 ** @param xcb_colormap_t mid 11338 ** @param xcb_window_t window 11339 ** @param xcb_visualid_t visual 11340 ** @returns xcb_void_cookie_t 11341 ** 11342 *****************************************************************************/ 11343 11344 xcb_void_cookie_t 11345 xcb_create_colormap (xcb_connection_t *c /**< */, 11346 uint8_t alloc /**< */, 11347 xcb_colormap_t mid /**< */, 11348 xcb_window_t window /**< */, 11349 xcb_visualid_t visual /**< */) 11350 { 11351 static const xcb_protocol_request_t xcb_req = { 11352 /* count */ 2, 11353 /* ext */ 0, 11354 /* opcode */ XCB_CREATE_COLORMAP, 11355 /* isvoid */ 1 11356 }; 11357 11358 struct iovec xcb_parts[4]; 11359 xcb_void_cookie_t xcb_ret; 11360 xcb_create_colormap_request_t xcb_out; 11361 11362 xcb_out.alloc = alloc; 11363 xcb_out.mid = mid; 11364 xcb_out.window = window; 11365 xcb_out.visual = visual; 11366 11367 xcb_parts[2].iov_base = (char *) &xcb_out; 11368 xcb_parts[2].iov_len = sizeof(xcb_out); 11369 xcb_parts[3].iov_base = 0; 11370 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11371 11372 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11373 return xcb_ret; 11374 } 11375 11376 11377 /***************************************************************************** 11378 ** 11379 ** xcb_void_cookie_t xcb_free_colormap_checked 11380 ** 11381 ** @param xcb_connection_t *c 11382 ** @param xcb_colormap_t cmap 11383 ** @returns xcb_void_cookie_t 11384 ** 11385 *****************************************************************************/ 11386 11387 xcb_void_cookie_t 11388 xcb_free_colormap_checked (xcb_connection_t *c /**< */, 11389 xcb_colormap_t cmap /**< */) 11390 { 11391 static const xcb_protocol_request_t xcb_req = { 11392 /* count */ 2, 11393 /* ext */ 0, 11394 /* opcode */ XCB_FREE_COLORMAP, 11395 /* isvoid */ 1 11396 }; 11397 11398 struct iovec xcb_parts[4]; 11399 xcb_void_cookie_t xcb_ret; 11400 xcb_free_colormap_request_t xcb_out; 11401 11402 xcb_out.pad0 = 0; 11403 xcb_out.cmap = cmap; 11404 11405 xcb_parts[2].iov_base = (char *) &xcb_out; 11406 xcb_parts[2].iov_len = sizeof(xcb_out); 11407 xcb_parts[3].iov_base = 0; 11408 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11409 11410 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11411 return xcb_ret; 11412 } 11413 11414 11415 /***************************************************************************** 11416 ** 11417 ** xcb_void_cookie_t xcb_free_colormap 11418 ** 11419 ** @param xcb_connection_t *c 11420 ** @param xcb_colormap_t cmap 11421 ** @returns xcb_void_cookie_t 11422 ** 11423 *****************************************************************************/ 11424 11425 xcb_void_cookie_t 11426 xcb_free_colormap (xcb_connection_t *c /**< */, 11427 xcb_colormap_t cmap /**< */) 11428 { 11429 static const xcb_protocol_request_t xcb_req = { 11430 /* count */ 2, 11431 /* ext */ 0, 11432 /* opcode */ XCB_FREE_COLORMAP, 11433 /* isvoid */ 1 11434 }; 11435 11436 struct iovec xcb_parts[4]; 11437 xcb_void_cookie_t xcb_ret; 11438 xcb_free_colormap_request_t xcb_out; 11439 11440 xcb_out.pad0 = 0; 11441 xcb_out.cmap = cmap; 11442 11443 xcb_parts[2].iov_base = (char *) &xcb_out; 11444 xcb_parts[2].iov_len = sizeof(xcb_out); 11445 xcb_parts[3].iov_base = 0; 11446 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11447 11448 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11449 return xcb_ret; 11450 } 11451 11452 11453 /***************************************************************************** 11454 ** 11455 ** xcb_void_cookie_t xcb_copy_colormap_and_free_checked 11456 ** 11457 ** @param xcb_connection_t *c 11458 ** @param xcb_colormap_t mid 11459 ** @param xcb_colormap_t src_cmap 11460 ** @returns xcb_void_cookie_t 11461 ** 11462 *****************************************************************************/ 11463 11464 xcb_void_cookie_t 11465 xcb_copy_colormap_and_free_checked (xcb_connection_t *c /**< */, 11466 xcb_colormap_t mid /**< */, 11467 xcb_colormap_t src_cmap /**< */) 11468 { 11469 static const xcb_protocol_request_t xcb_req = { 11470 /* count */ 2, 11471 /* ext */ 0, 11472 /* opcode */ XCB_COPY_COLORMAP_AND_FREE, 11473 /* isvoid */ 1 11474 }; 11475 11476 struct iovec xcb_parts[4]; 11477 xcb_void_cookie_t xcb_ret; 11478 xcb_copy_colormap_and_free_request_t xcb_out; 11479 11480 xcb_out.pad0 = 0; 11481 xcb_out.mid = mid; 11482 xcb_out.src_cmap = src_cmap; 11483 11484 xcb_parts[2].iov_base = (char *) &xcb_out; 11485 xcb_parts[2].iov_len = sizeof(xcb_out); 11486 xcb_parts[3].iov_base = 0; 11487 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11488 11489 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11490 return xcb_ret; 11491 } 11492 11493 11494 /***************************************************************************** 11495 ** 11496 ** xcb_void_cookie_t xcb_copy_colormap_and_free 11497 ** 11498 ** @param xcb_connection_t *c 11499 ** @param xcb_colormap_t mid 11500 ** @param xcb_colormap_t src_cmap 11501 ** @returns xcb_void_cookie_t 11502 ** 11503 *****************************************************************************/ 11504 11505 xcb_void_cookie_t 11506 xcb_copy_colormap_and_free (xcb_connection_t *c /**< */, 11507 xcb_colormap_t mid /**< */, 11508 xcb_colormap_t src_cmap /**< */) 11509 { 11510 static const xcb_protocol_request_t xcb_req = { 11511 /* count */ 2, 11512 /* ext */ 0, 11513 /* opcode */ XCB_COPY_COLORMAP_AND_FREE, 11514 /* isvoid */ 1 11515 }; 11516 11517 struct iovec xcb_parts[4]; 11518 xcb_void_cookie_t xcb_ret; 11519 xcb_copy_colormap_and_free_request_t xcb_out; 11520 11521 xcb_out.pad0 = 0; 11522 xcb_out.mid = mid; 11523 xcb_out.src_cmap = src_cmap; 11524 11525 xcb_parts[2].iov_base = (char *) &xcb_out; 11526 xcb_parts[2].iov_len = sizeof(xcb_out); 11527 xcb_parts[3].iov_base = 0; 11528 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11529 11530 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11531 return xcb_ret; 11532 } 11533 11534 11535 /***************************************************************************** 11536 ** 11537 ** xcb_void_cookie_t xcb_install_colormap_checked 11538 ** 11539 ** @param xcb_connection_t *c 11540 ** @param xcb_colormap_t cmap 11541 ** @returns xcb_void_cookie_t 11542 ** 11543 *****************************************************************************/ 11544 11545 xcb_void_cookie_t 11546 xcb_install_colormap_checked (xcb_connection_t *c /**< */, 11547 xcb_colormap_t cmap /**< */) 11548 { 11549 static const xcb_protocol_request_t xcb_req = { 11550 /* count */ 2, 11551 /* ext */ 0, 11552 /* opcode */ XCB_INSTALL_COLORMAP, 11553 /* isvoid */ 1 11554 }; 11555 11556 struct iovec xcb_parts[4]; 11557 xcb_void_cookie_t xcb_ret; 11558 xcb_install_colormap_request_t xcb_out; 11559 11560 xcb_out.pad0 = 0; 11561 xcb_out.cmap = cmap; 11562 11563 xcb_parts[2].iov_base = (char *) &xcb_out; 11564 xcb_parts[2].iov_len = sizeof(xcb_out); 11565 xcb_parts[3].iov_base = 0; 11566 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11567 11568 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11569 return xcb_ret; 11570 } 11571 11572 11573 /***************************************************************************** 11574 ** 11575 ** xcb_void_cookie_t xcb_install_colormap 11576 ** 11577 ** @param xcb_connection_t *c 11578 ** @param xcb_colormap_t cmap 11579 ** @returns xcb_void_cookie_t 11580 ** 11581 *****************************************************************************/ 11582 11583 xcb_void_cookie_t 11584 xcb_install_colormap (xcb_connection_t *c /**< */, 11585 xcb_colormap_t cmap /**< */) 11586 { 11587 static const xcb_protocol_request_t xcb_req = { 11588 /* count */ 2, 11589 /* ext */ 0, 11590 /* opcode */ XCB_INSTALL_COLORMAP, 11591 /* isvoid */ 1 11592 }; 11593 11594 struct iovec xcb_parts[4]; 11595 xcb_void_cookie_t xcb_ret; 11596 xcb_install_colormap_request_t xcb_out; 11597 11598 xcb_out.pad0 = 0; 11599 xcb_out.cmap = cmap; 11600 11601 xcb_parts[2].iov_base = (char *) &xcb_out; 11602 xcb_parts[2].iov_len = sizeof(xcb_out); 11603 xcb_parts[3].iov_base = 0; 11604 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11605 11606 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11607 return xcb_ret; 11608 } 11609 11610 11611 /***************************************************************************** 11612 ** 11613 ** xcb_void_cookie_t xcb_uninstall_colormap_checked 11614 ** 11615 ** @param xcb_connection_t *c 11616 ** @param xcb_colormap_t cmap 11617 ** @returns xcb_void_cookie_t 11618 ** 11619 *****************************************************************************/ 11620 11621 xcb_void_cookie_t 11622 xcb_uninstall_colormap_checked (xcb_connection_t *c /**< */, 11623 xcb_colormap_t cmap /**< */) 11624 { 11625 static const xcb_protocol_request_t xcb_req = { 11626 /* count */ 2, 11627 /* ext */ 0, 11628 /* opcode */ XCB_UNINSTALL_COLORMAP, 11629 /* isvoid */ 1 11630 }; 11631 11632 struct iovec xcb_parts[4]; 11633 xcb_void_cookie_t xcb_ret; 11634 xcb_uninstall_colormap_request_t xcb_out; 11635 11636 xcb_out.pad0 = 0; 11637 xcb_out.cmap = cmap; 11638 11639 xcb_parts[2].iov_base = (char *) &xcb_out; 11640 xcb_parts[2].iov_len = sizeof(xcb_out); 11641 xcb_parts[3].iov_base = 0; 11642 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11643 11644 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11645 return xcb_ret; 11646 } 11647 11648 11649 /***************************************************************************** 11650 ** 11651 ** xcb_void_cookie_t xcb_uninstall_colormap 11652 ** 11653 ** @param xcb_connection_t *c 11654 ** @param xcb_colormap_t cmap 11655 ** @returns xcb_void_cookie_t 11656 ** 11657 *****************************************************************************/ 11658 11659 xcb_void_cookie_t 11660 xcb_uninstall_colormap (xcb_connection_t *c /**< */, 11661 xcb_colormap_t cmap /**< */) 11662 { 11663 static const xcb_protocol_request_t xcb_req = { 11664 /* count */ 2, 11665 /* ext */ 0, 11666 /* opcode */ XCB_UNINSTALL_COLORMAP, 11667 /* isvoid */ 1 11668 }; 11669 11670 struct iovec xcb_parts[4]; 11671 xcb_void_cookie_t xcb_ret; 11672 xcb_uninstall_colormap_request_t xcb_out; 11673 11674 xcb_out.pad0 = 0; 11675 xcb_out.cmap = cmap; 11676 11677 xcb_parts[2].iov_base = (char *) &xcb_out; 11678 xcb_parts[2].iov_len = sizeof(xcb_out); 11679 xcb_parts[3].iov_base = 0; 11680 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11681 11682 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11683 return xcb_ret; 11684 } 11685 11686 int 11687 xcb_list_installed_colormaps_sizeof (const void *_buffer /**< */) 11688 { 11689 char *xcb_tmp = (char *)_buffer; 11690 const xcb_list_installed_colormaps_reply_t *_aux = (xcb_list_installed_colormaps_reply_t *)_buffer; 11691 unsigned int xcb_buffer_len = 0; 11692 unsigned int xcb_block_len = 0; 11693 unsigned int xcb_pad = 0; 11694 unsigned int xcb_align_to; 11695 11696 11697 xcb_block_len += sizeof(xcb_list_installed_colormaps_reply_t); 11698 xcb_tmp += xcb_block_len; 11699 /* cmaps */ 11700 xcb_block_len += _aux->cmaps_len * sizeof(xcb_colormap_t); 11701 xcb_tmp += xcb_block_len; 11702 xcb_align_to = ALIGNOF(xcb_colormap_t); 11703 /* insert padding */ 11704 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11705 xcb_buffer_len += xcb_block_len + xcb_pad; 11706 if (0 != xcb_pad) { 11707 xcb_tmp += xcb_pad; 11708 xcb_pad = 0; 11709 } 11710 xcb_block_len = 0; 11711 11712 return xcb_buffer_len; 11713 } 11714 11715 11716 /***************************************************************************** 11717 ** 11718 ** xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps 11719 ** 11720 ** @param xcb_connection_t *c 11721 ** @param xcb_window_t window 11722 ** @returns xcb_list_installed_colormaps_cookie_t 11723 ** 11724 *****************************************************************************/ 11725 11726 xcb_list_installed_colormaps_cookie_t 11727 xcb_list_installed_colormaps (xcb_connection_t *c /**< */, 11728 xcb_window_t window /**< */) 11729 { 11730 static const xcb_protocol_request_t xcb_req = { 11731 /* count */ 2, 11732 /* ext */ 0, 11733 /* opcode */ XCB_LIST_INSTALLED_COLORMAPS, 11734 /* isvoid */ 0 11735 }; 11736 11737 struct iovec xcb_parts[4]; 11738 xcb_list_installed_colormaps_cookie_t xcb_ret; 11739 xcb_list_installed_colormaps_request_t xcb_out; 11740 11741 xcb_out.pad0 = 0; 11742 xcb_out.window = window; 11743 11744 xcb_parts[2].iov_base = (char *) &xcb_out; 11745 xcb_parts[2].iov_len = sizeof(xcb_out); 11746 xcb_parts[3].iov_base = 0; 11747 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11748 11749 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11750 return xcb_ret; 11751 } 11752 11753 11754 /***************************************************************************** 11755 ** 11756 ** xcb_list_installed_colormaps_cookie_t xcb_list_installed_colormaps_unchecked 11757 ** 11758 ** @param xcb_connection_t *c 11759 ** @param xcb_window_t window 11760 ** @returns xcb_list_installed_colormaps_cookie_t 11761 ** 11762 *****************************************************************************/ 11763 11764 xcb_list_installed_colormaps_cookie_t 11765 xcb_list_installed_colormaps_unchecked (xcb_connection_t *c /**< */, 11766 xcb_window_t window /**< */) 11767 { 11768 static const xcb_protocol_request_t xcb_req = { 11769 /* count */ 2, 11770 /* ext */ 0, 11771 /* opcode */ XCB_LIST_INSTALLED_COLORMAPS, 11772 /* isvoid */ 0 11773 }; 11774 11775 struct iovec xcb_parts[4]; 11776 xcb_list_installed_colormaps_cookie_t xcb_ret; 11777 xcb_list_installed_colormaps_request_t xcb_out; 11778 11779 xcb_out.pad0 = 0; 11780 xcb_out.window = window; 11781 11782 xcb_parts[2].iov_base = (char *) &xcb_out; 11783 xcb_parts[2].iov_len = sizeof(xcb_out); 11784 xcb_parts[3].iov_base = 0; 11785 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11786 11787 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11788 return xcb_ret; 11789 } 11790 11791 11792 /***************************************************************************** 11793 ** 11794 ** xcb_colormap_t * xcb_list_installed_colormaps_cmaps 11795 ** 11796 ** @param const xcb_list_installed_colormaps_reply_t *R 11797 ** @returns xcb_colormap_t * 11798 ** 11799 *****************************************************************************/ 11800 11801 xcb_colormap_t * 11802 xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R /**< */) 11803 { 11804 return (xcb_colormap_t *) (R + 1); 11805 } 11806 11807 11808 /***************************************************************************** 11809 ** 11810 ** int xcb_list_installed_colormaps_cmaps_length 11811 ** 11812 ** @param const xcb_list_installed_colormaps_reply_t *R 11813 ** @returns int 11814 ** 11815 *****************************************************************************/ 11816 11817 int 11818 xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R /**< */) 11819 { 11820 return R->cmaps_len; 11821 } 11822 11823 11824 /***************************************************************************** 11825 ** 11826 ** xcb_generic_iterator_t xcb_list_installed_colormaps_cmaps_end 11827 ** 11828 ** @param const xcb_list_installed_colormaps_reply_t *R 11829 ** @returns xcb_generic_iterator_t 11830 ** 11831 *****************************************************************************/ 11832 11833 xcb_generic_iterator_t 11834 xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R /**< */) 11835 { 11836 xcb_generic_iterator_t i; 11837 i.data = ((xcb_colormap_t *) (R + 1)) + (R->cmaps_len); 11838 i.rem = 0; 11839 i.index = (char *) i.data - (char *) R; 11840 return i; 11841 } 11842 11843 11844 /***************************************************************************** 11845 ** 11846 ** xcb_list_installed_colormaps_reply_t * xcb_list_installed_colormaps_reply 11847 ** 11848 ** @param xcb_connection_t *c 11849 ** @param xcb_list_installed_colormaps_cookie_t cookie 11850 ** @param xcb_generic_error_t **e 11851 ** @returns xcb_list_installed_colormaps_reply_t * 11852 ** 11853 *****************************************************************************/ 11854 11855 xcb_list_installed_colormaps_reply_t * 11856 xcb_list_installed_colormaps_reply (xcb_connection_t *c /**< */, 11857 xcb_list_installed_colormaps_cookie_t cookie /**< */, 11858 xcb_generic_error_t **e /**< */) 11859 { 11860 return (xcb_list_installed_colormaps_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11861 } 11862 11863 11864 /***************************************************************************** 11865 ** 11866 ** xcb_alloc_color_cookie_t xcb_alloc_color 11867 ** 11868 ** @param xcb_connection_t *c 11869 ** @param xcb_colormap_t cmap 11870 ** @param uint16_t red 11871 ** @param uint16_t green 11872 ** @param uint16_t blue 11873 ** @returns xcb_alloc_color_cookie_t 11874 ** 11875 *****************************************************************************/ 11876 11877 xcb_alloc_color_cookie_t 11878 xcb_alloc_color (xcb_connection_t *c /**< */, 11879 xcb_colormap_t cmap /**< */, 11880 uint16_t red /**< */, 11881 uint16_t green /**< */, 11882 uint16_t blue /**< */) 11883 { 11884 static const xcb_protocol_request_t xcb_req = { 11885 /* count */ 2, 11886 /* ext */ 0, 11887 /* opcode */ XCB_ALLOC_COLOR, 11888 /* isvoid */ 0 11889 }; 11890 11891 struct iovec xcb_parts[4]; 11892 xcb_alloc_color_cookie_t xcb_ret; 11893 xcb_alloc_color_request_t xcb_out; 11894 11895 xcb_out.pad0 = 0; 11896 xcb_out.cmap = cmap; 11897 xcb_out.red = red; 11898 xcb_out.green = green; 11899 xcb_out.blue = blue; 11900 memset(xcb_out.pad1, 0, 2); 11901 11902 xcb_parts[2].iov_base = (char *) &xcb_out; 11903 xcb_parts[2].iov_len = sizeof(xcb_out); 11904 xcb_parts[3].iov_base = 0; 11905 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11906 11907 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 11908 return xcb_ret; 11909 } 11910 11911 11912 /***************************************************************************** 11913 ** 11914 ** xcb_alloc_color_cookie_t xcb_alloc_color_unchecked 11915 ** 11916 ** @param xcb_connection_t *c 11917 ** @param xcb_colormap_t cmap 11918 ** @param uint16_t red 11919 ** @param uint16_t green 11920 ** @param uint16_t blue 11921 ** @returns xcb_alloc_color_cookie_t 11922 ** 11923 *****************************************************************************/ 11924 11925 xcb_alloc_color_cookie_t 11926 xcb_alloc_color_unchecked (xcb_connection_t *c /**< */, 11927 xcb_colormap_t cmap /**< */, 11928 uint16_t red /**< */, 11929 uint16_t green /**< */, 11930 uint16_t blue /**< */) 11931 { 11932 static const xcb_protocol_request_t xcb_req = { 11933 /* count */ 2, 11934 /* ext */ 0, 11935 /* opcode */ XCB_ALLOC_COLOR, 11936 /* isvoid */ 0 11937 }; 11938 11939 struct iovec xcb_parts[4]; 11940 xcb_alloc_color_cookie_t xcb_ret; 11941 xcb_alloc_color_request_t xcb_out; 11942 11943 xcb_out.pad0 = 0; 11944 xcb_out.cmap = cmap; 11945 xcb_out.red = red; 11946 xcb_out.green = green; 11947 xcb_out.blue = blue; 11948 memset(xcb_out.pad1, 0, 2); 11949 11950 xcb_parts[2].iov_base = (char *) &xcb_out; 11951 xcb_parts[2].iov_len = sizeof(xcb_out); 11952 xcb_parts[3].iov_base = 0; 11953 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 11954 11955 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 11956 return xcb_ret; 11957 } 11958 11959 11960 /***************************************************************************** 11961 ** 11962 ** xcb_alloc_color_reply_t * xcb_alloc_color_reply 11963 ** 11964 ** @param xcb_connection_t *c 11965 ** @param xcb_alloc_color_cookie_t cookie 11966 ** @param xcb_generic_error_t **e 11967 ** @returns xcb_alloc_color_reply_t * 11968 ** 11969 *****************************************************************************/ 11970 11971 xcb_alloc_color_reply_t * 11972 xcb_alloc_color_reply (xcb_connection_t *c /**< */, 11973 xcb_alloc_color_cookie_t cookie /**< */, 11974 xcb_generic_error_t **e /**< */) 11975 { 11976 return (xcb_alloc_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 11977 } 11978 11979 int 11980 xcb_alloc_named_color_sizeof (const void *_buffer /**< */) 11981 { 11982 char *xcb_tmp = (char *)_buffer; 11983 const xcb_alloc_named_color_request_t *_aux = (xcb_alloc_named_color_request_t *)_buffer; 11984 unsigned int xcb_buffer_len = 0; 11985 unsigned int xcb_block_len = 0; 11986 unsigned int xcb_pad = 0; 11987 unsigned int xcb_align_to; 11988 11989 11990 xcb_block_len += sizeof(xcb_alloc_named_color_request_t); 11991 xcb_tmp += xcb_block_len; 11992 /* name */ 11993 xcb_block_len += _aux->name_len * sizeof(char); 11994 xcb_tmp += xcb_block_len; 11995 xcb_align_to = ALIGNOF(char); 11996 /* insert padding */ 11997 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 11998 xcb_buffer_len += xcb_block_len + xcb_pad; 11999 if (0 != xcb_pad) { 12000 xcb_tmp += xcb_pad; 12001 xcb_pad = 0; 12002 } 12003 xcb_block_len = 0; 12004 12005 return xcb_buffer_len; 12006 } 12007 12008 12009 /***************************************************************************** 12010 ** 12011 ** xcb_alloc_named_color_cookie_t xcb_alloc_named_color 12012 ** 12013 ** @param xcb_connection_t *c 12014 ** @param xcb_colormap_t cmap 12015 ** @param uint16_t name_len 12016 ** @param const char *name 12017 ** @returns xcb_alloc_named_color_cookie_t 12018 ** 12019 *****************************************************************************/ 12020 12021 xcb_alloc_named_color_cookie_t 12022 xcb_alloc_named_color (xcb_connection_t *c /**< */, 12023 xcb_colormap_t cmap /**< */, 12024 uint16_t name_len /**< */, 12025 const char *name /**< */) 12026 { 12027 static const xcb_protocol_request_t xcb_req = { 12028 /* count */ 4, 12029 /* ext */ 0, 12030 /* opcode */ XCB_ALLOC_NAMED_COLOR, 12031 /* isvoid */ 0 12032 }; 12033 12034 struct iovec xcb_parts[6]; 12035 xcb_alloc_named_color_cookie_t xcb_ret; 12036 xcb_alloc_named_color_request_t xcb_out; 12037 12038 xcb_out.pad0 = 0; 12039 xcb_out.cmap = cmap; 12040 xcb_out.name_len = name_len; 12041 memset(xcb_out.pad1, 0, 2); 12042 12043 xcb_parts[2].iov_base = (char *) &xcb_out; 12044 xcb_parts[2].iov_len = sizeof(xcb_out); 12045 xcb_parts[3].iov_base = 0; 12046 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12047 /* char name */ 12048 xcb_parts[4].iov_base = (char *) name; 12049 xcb_parts[4].iov_len = name_len * sizeof(char); 12050 xcb_parts[5].iov_base = 0; 12051 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12052 12053 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12054 return xcb_ret; 12055 } 12056 12057 12058 /***************************************************************************** 12059 ** 12060 ** xcb_alloc_named_color_cookie_t xcb_alloc_named_color_unchecked 12061 ** 12062 ** @param xcb_connection_t *c 12063 ** @param xcb_colormap_t cmap 12064 ** @param uint16_t name_len 12065 ** @param const char *name 12066 ** @returns xcb_alloc_named_color_cookie_t 12067 ** 12068 *****************************************************************************/ 12069 12070 xcb_alloc_named_color_cookie_t 12071 xcb_alloc_named_color_unchecked (xcb_connection_t *c /**< */, 12072 xcb_colormap_t cmap /**< */, 12073 uint16_t name_len /**< */, 12074 const char *name /**< */) 12075 { 12076 static const xcb_protocol_request_t xcb_req = { 12077 /* count */ 4, 12078 /* ext */ 0, 12079 /* opcode */ XCB_ALLOC_NAMED_COLOR, 12080 /* isvoid */ 0 12081 }; 12082 12083 struct iovec xcb_parts[6]; 12084 xcb_alloc_named_color_cookie_t xcb_ret; 12085 xcb_alloc_named_color_request_t xcb_out; 12086 12087 xcb_out.pad0 = 0; 12088 xcb_out.cmap = cmap; 12089 xcb_out.name_len = name_len; 12090 memset(xcb_out.pad1, 0, 2); 12091 12092 xcb_parts[2].iov_base = (char *) &xcb_out; 12093 xcb_parts[2].iov_len = sizeof(xcb_out); 12094 xcb_parts[3].iov_base = 0; 12095 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12096 /* char name */ 12097 xcb_parts[4].iov_base = (char *) name; 12098 xcb_parts[4].iov_len = name_len * sizeof(char); 12099 xcb_parts[5].iov_base = 0; 12100 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12101 12102 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12103 return xcb_ret; 12104 } 12105 12106 12107 /***************************************************************************** 12108 ** 12109 ** xcb_alloc_named_color_reply_t * xcb_alloc_named_color_reply 12110 ** 12111 ** @param xcb_connection_t *c 12112 ** @param xcb_alloc_named_color_cookie_t cookie 12113 ** @param xcb_generic_error_t **e 12114 ** @returns xcb_alloc_named_color_reply_t * 12115 ** 12116 *****************************************************************************/ 12117 12118 xcb_alloc_named_color_reply_t * 12119 xcb_alloc_named_color_reply (xcb_connection_t *c /**< */, 12120 xcb_alloc_named_color_cookie_t cookie /**< */, 12121 xcb_generic_error_t **e /**< */) 12122 { 12123 return (xcb_alloc_named_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12124 } 12125 12126 int 12127 xcb_alloc_color_cells_sizeof (const void *_buffer /**< */) 12128 { 12129 char *xcb_tmp = (char *)_buffer; 12130 const xcb_alloc_color_cells_reply_t *_aux = (xcb_alloc_color_cells_reply_t *)_buffer; 12131 unsigned int xcb_buffer_len = 0; 12132 unsigned int xcb_block_len = 0; 12133 unsigned int xcb_pad = 0; 12134 unsigned int xcb_align_to; 12135 12136 12137 xcb_block_len += sizeof(xcb_alloc_color_cells_reply_t); 12138 xcb_tmp += xcb_block_len; 12139 /* pixels */ 12140 xcb_block_len += _aux->pixels_len * sizeof(uint32_t); 12141 xcb_tmp += xcb_block_len; 12142 xcb_align_to = ALIGNOF(uint32_t); 12143 /* insert padding */ 12144 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12145 xcb_buffer_len += xcb_block_len + xcb_pad; 12146 if (0 != xcb_pad) { 12147 xcb_tmp += xcb_pad; 12148 xcb_pad = 0; 12149 } 12150 xcb_block_len = 0; 12151 /* masks */ 12152 xcb_block_len += _aux->masks_len * sizeof(uint32_t); 12153 xcb_tmp += xcb_block_len; 12154 xcb_align_to = ALIGNOF(uint32_t); 12155 /* insert padding */ 12156 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12157 xcb_buffer_len += xcb_block_len + xcb_pad; 12158 if (0 != xcb_pad) { 12159 xcb_tmp += xcb_pad; 12160 xcb_pad = 0; 12161 } 12162 xcb_block_len = 0; 12163 12164 return xcb_buffer_len; 12165 } 12166 12167 12168 /***************************************************************************** 12169 ** 12170 ** xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells 12171 ** 12172 ** @param xcb_connection_t *c 12173 ** @param uint8_t contiguous 12174 ** @param xcb_colormap_t cmap 12175 ** @param uint16_t colors 12176 ** @param uint16_t planes 12177 ** @returns xcb_alloc_color_cells_cookie_t 12178 ** 12179 *****************************************************************************/ 12180 12181 xcb_alloc_color_cells_cookie_t 12182 xcb_alloc_color_cells (xcb_connection_t *c /**< */, 12183 uint8_t contiguous /**< */, 12184 xcb_colormap_t cmap /**< */, 12185 uint16_t colors /**< */, 12186 uint16_t planes /**< */) 12187 { 12188 static const xcb_protocol_request_t xcb_req = { 12189 /* count */ 2, 12190 /* ext */ 0, 12191 /* opcode */ XCB_ALLOC_COLOR_CELLS, 12192 /* isvoid */ 0 12193 }; 12194 12195 struct iovec xcb_parts[4]; 12196 xcb_alloc_color_cells_cookie_t xcb_ret; 12197 xcb_alloc_color_cells_request_t xcb_out; 12198 12199 xcb_out.contiguous = contiguous; 12200 xcb_out.cmap = cmap; 12201 xcb_out.colors = colors; 12202 xcb_out.planes = planes; 12203 12204 xcb_parts[2].iov_base = (char *) &xcb_out; 12205 xcb_parts[2].iov_len = sizeof(xcb_out); 12206 xcb_parts[3].iov_base = 0; 12207 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12208 12209 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12210 return xcb_ret; 12211 } 12212 12213 12214 /***************************************************************************** 12215 ** 12216 ** xcb_alloc_color_cells_cookie_t xcb_alloc_color_cells_unchecked 12217 ** 12218 ** @param xcb_connection_t *c 12219 ** @param uint8_t contiguous 12220 ** @param xcb_colormap_t cmap 12221 ** @param uint16_t colors 12222 ** @param uint16_t planes 12223 ** @returns xcb_alloc_color_cells_cookie_t 12224 ** 12225 *****************************************************************************/ 12226 12227 xcb_alloc_color_cells_cookie_t 12228 xcb_alloc_color_cells_unchecked (xcb_connection_t *c /**< */, 12229 uint8_t contiguous /**< */, 12230 xcb_colormap_t cmap /**< */, 12231 uint16_t colors /**< */, 12232 uint16_t planes /**< */) 12233 { 12234 static const xcb_protocol_request_t xcb_req = { 12235 /* count */ 2, 12236 /* ext */ 0, 12237 /* opcode */ XCB_ALLOC_COLOR_CELLS, 12238 /* isvoid */ 0 12239 }; 12240 12241 struct iovec xcb_parts[4]; 12242 xcb_alloc_color_cells_cookie_t xcb_ret; 12243 xcb_alloc_color_cells_request_t xcb_out; 12244 12245 xcb_out.contiguous = contiguous; 12246 xcb_out.cmap = cmap; 12247 xcb_out.colors = colors; 12248 xcb_out.planes = planes; 12249 12250 xcb_parts[2].iov_base = (char *) &xcb_out; 12251 xcb_parts[2].iov_len = sizeof(xcb_out); 12252 xcb_parts[3].iov_base = 0; 12253 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12254 12255 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12256 return xcb_ret; 12257 } 12258 12259 12260 /***************************************************************************** 12261 ** 12262 ** uint32_t * xcb_alloc_color_cells_pixels 12263 ** 12264 ** @param const xcb_alloc_color_cells_reply_t *R 12265 ** @returns uint32_t * 12266 ** 12267 *****************************************************************************/ 12268 12269 uint32_t * 12270 xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R /**< */) 12271 { 12272 return (uint32_t *) (R + 1); 12273 } 12274 12275 12276 /***************************************************************************** 12277 ** 12278 ** int xcb_alloc_color_cells_pixels_length 12279 ** 12280 ** @param const xcb_alloc_color_cells_reply_t *R 12281 ** @returns int 12282 ** 12283 *****************************************************************************/ 12284 12285 int 12286 xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R /**< */) 12287 { 12288 return R->pixels_len; 12289 } 12290 12291 12292 /***************************************************************************** 12293 ** 12294 ** xcb_generic_iterator_t xcb_alloc_color_cells_pixels_end 12295 ** 12296 ** @param const xcb_alloc_color_cells_reply_t *R 12297 ** @returns xcb_generic_iterator_t 12298 ** 12299 *****************************************************************************/ 12300 12301 xcb_generic_iterator_t 12302 xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R /**< */) 12303 { 12304 xcb_generic_iterator_t i; 12305 i.data = ((uint32_t *) (R + 1)) + (R->pixels_len); 12306 i.rem = 0; 12307 i.index = (char *) i.data - (char *) R; 12308 return i; 12309 } 12310 12311 12312 /***************************************************************************** 12313 ** 12314 ** uint32_t * xcb_alloc_color_cells_masks 12315 ** 12316 ** @param const xcb_alloc_color_cells_reply_t *R 12317 ** @returns uint32_t * 12318 ** 12319 *****************************************************************************/ 12320 12321 uint32_t * 12322 xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R /**< */) 12323 { 12324 xcb_generic_iterator_t prev = xcb_alloc_color_cells_pixels_end(R); 12325 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 0); 12326 } 12327 12328 12329 /***************************************************************************** 12330 ** 12331 ** int xcb_alloc_color_cells_masks_length 12332 ** 12333 ** @param const xcb_alloc_color_cells_reply_t *R 12334 ** @returns int 12335 ** 12336 *****************************************************************************/ 12337 12338 int 12339 xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R /**< */) 12340 { 12341 return R->masks_len; 12342 } 12343 12344 12345 /***************************************************************************** 12346 ** 12347 ** xcb_generic_iterator_t xcb_alloc_color_cells_masks_end 12348 ** 12349 ** @param const xcb_alloc_color_cells_reply_t *R 12350 ** @returns xcb_generic_iterator_t 12351 ** 12352 *****************************************************************************/ 12353 12354 xcb_generic_iterator_t 12355 xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R /**< */) 12356 { 12357 xcb_generic_iterator_t i; 12358 xcb_generic_iterator_t child = xcb_alloc_color_cells_pixels_end(R); 12359 i.data = ((uint32_t *) child.data) + (R->masks_len); 12360 i.rem = 0; 12361 i.index = (char *) i.data - (char *) R; 12362 return i; 12363 } 12364 12365 12366 /***************************************************************************** 12367 ** 12368 ** xcb_alloc_color_cells_reply_t * xcb_alloc_color_cells_reply 12369 ** 12370 ** @param xcb_connection_t *c 12371 ** @param xcb_alloc_color_cells_cookie_t cookie 12372 ** @param xcb_generic_error_t **e 12373 ** @returns xcb_alloc_color_cells_reply_t * 12374 ** 12375 *****************************************************************************/ 12376 12377 xcb_alloc_color_cells_reply_t * 12378 xcb_alloc_color_cells_reply (xcb_connection_t *c /**< */, 12379 xcb_alloc_color_cells_cookie_t cookie /**< */, 12380 xcb_generic_error_t **e /**< */) 12381 { 12382 return (xcb_alloc_color_cells_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12383 } 12384 12385 int 12386 xcb_alloc_color_planes_sizeof (const void *_buffer /**< */) 12387 { 12388 char *xcb_tmp = (char *)_buffer; 12389 const xcb_alloc_color_planes_reply_t *_aux = (xcb_alloc_color_planes_reply_t *)_buffer; 12390 unsigned int xcb_buffer_len = 0; 12391 unsigned int xcb_block_len = 0; 12392 unsigned int xcb_pad = 0; 12393 unsigned int xcb_align_to; 12394 12395 12396 xcb_block_len += sizeof(xcb_alloc_color_planes_reply_t); 12397 xcb_tmp += xcb_block_len; 12398 /* pixels */ 12399 xcb_block_len += _aux->pixels_len * sizeof(uint32_t); 12400 xcb_tmp += xcb_block_len; 12401 xcb_align_to = ALIGNOF(uint32_t); 12402 /* insert padding */ 12403 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12404 xcb_buffer_len += xcb_block_len + xcb_pad; 12405 if (0 != xcb_pad) { 12406 xcb_tmp += xcb_pad; 12407 xcb_pad = 0; 12408 } 12409 xcb_block_len = 0; 12410 12411 return xcb_buffer_len; 12412 } 12413 12414 12415 /***************************************************************************** 12416 ** 12417 ** xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes 12418 ** 12419 ** @param xcb_connection_t *c 12420 ** @param uint8_t contiguous 12421 ** @param xcb_colormap_t cmap 12422 ** @param uint16_t colors 12423 ** @param uint16_t reds 12424 ** @param uint16_t greens 12425 ** @param uint16_t blues 12426 ** @returns xcb_alloc_color_planes_cookie_t 12427 ** 12428 *****************************************************************************/ 12429 12430 xcb_alloc_color_planes_cookie_t 12431 xcb_alloc_color_planes (xcb_connection_t *c /**< */, 12432 uint8_t contiguous /**< */, 12433 xcb_colormap_t cmap /**< */, 12434 uint16_t colors /**< */, 12435 uint16_t reds /**< */, 12436 uint16_t greens /**< */, 12437 uint16_t blues /**< */) 12438 { 12439 static const xcb_protocol_request_t xcb_req = { 12440 /* count */ 2, 12441 /* ext */ 0, 12442 /* opcode */ XCB_ALLOC_COLOR_PLANES, 12443 /* isvoid */ 0 12444 }; 12445 12446 struct iovec xcb_parts[4]; 12447 xcb_alloc_color_planes_cookie_t xcb_ret; 12448 xcb_alloc_color_planes_request_t xcb_out; 12449 12450 xcb_out.contiguous = contiguous; 12451 xcb_out.cmap = cmap; 12452 xcb_out.colors = colors; 12453 xcb_out.reds = reds; 12454 xcb_out.greens = greens; 12455 xcb_out.blues = blues; 12456 12457 xcb_parts[2].iov_base = (char *) &xcb_out; 12458 xcb_parts[2].iov_len = sizeof(xcb_out); 12459 xcb_parts[3].iov_base = 0; 12460 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12461 12462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12463 return xcb_ret; 12464 } 12465 12466 12467 /***************************************************************************** 12468 ** 12469 ** xcb_alloc_color_planes_cookie_t xcb_alloc_color_planes_unchecked 12470 ** 12471 ** @param xcb_connection_t *c 12472 ** @param uint8_t contiguous 12473 ** @param xcb_colormap_t cmap 12474 ** @param uint16_t colors 12475 ** @param uint16_t reds 12476 ** @param uint16_t greens 12477 ** @param uint16_t blues 12478 ** @returns xcb_alloc_color_planes_cookie_t 12479 ** 12480 *****************************************************************************/ 12481 12482 xcb_alloc_color_planes_cookie_t 12483 xcb_alloc_color_planes_unchecked (xcb_connection_t *c /**< */, 12484 uint8_t contiguous /**< */, 12485 xcb_colormap_t cmap /**< */, 12486 uint16_t colors /**< */, 12487 uint16_t reds /**< */, 12488 uint16_t greens /**< */, 12489 uint16_t blues /**< */) 12490 { 12491 static const xcb_protocol_request_t xcb_req = { 12492 /* count */ 2, 12493 /* ext */ 0, 12494 /* opcode */ XCB_ALLOC_COLOR_PLANES, 12495 /* isvoid */ 0 12496 }; 12497 12498 struct iovec xcb_parts[4]; 12499 xcb_alloc_color_planes_cookie_t xcb_ret; 12500 xcb_alloc_color_planes_request_t xcb_out; 12501 12502 xcb_out.contiguous = contiguous; 12503 xcb_out.cmap = cmap; 12504 xcb_out.colors = colors; 12505 xcb_out.reds = reds; 12506 xcb_out.greens = greens; 12507 xcb_out.blues = blues; 12508 12509 xcb_parts[2].iov_base = (char *) &xcb_out; 12510 xcb_parts[2].iov_len = sizeof(xcb_out); 12511 xcb_parts[3].iov_base = 0; 12512 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12513 12514 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12515 return xcb_ret; 12516 } 12517 12518 12519 /***************************************************************************** 12520 ** 12521 ** uint32_t * xcb_alloc_color_planes_pixels 12522 ** 12523 ** @param const xcb_alloc_color_planes_reply_t *R 12524 ** @returns uint32_t * 12525 ** 12526 *****************************************************************************/ 12527 12528 uint32_t * 12529 xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R /**< */) 12530 { 12531 return (uint32_t *) (R + 1); 12532 } 12533 12534 12535 /***************************************************************************** 12536 ** 12537 ** int xcb_alloc_color_planes_pixels_length 12538 ** 12539 ** @param const xcb_alloc_color_planes_reply_t *R 12540 ** @returns int 12541 ** 12542 *****************************************************************************/ 12543 12544 int 12545 xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R /**< */) 12546 { 12547 return R->pixels_len; 12548 } 12549 12550 12551 /***************************************************************************** 12552 ** 12553 ** xcb_generic_iterator_t xcb_alloc_color_planes_pixels_end 12554 ** 12555 ** @param const xcb_alloc_color_planes_reply_t *R 12556 ** @returns xcb_generic_iterator_t 12557 ** 12558 *****************************************************************************/ 12559 12560 xcb_generic_iterator_t 12561 xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R /**< */) 12562 { 12563 xcb_generic_iterator_t i; 12564 i.data = ((uint32_t *) (R + 1)) + (R->pixels_len); 12565 i.rem = 0; 12566 i.index = (char *) i.data - (char *) R; 12567 return i; 12568 } 12569 12570 12571 /***************************************************************************** 12572 ** 12573 ** xcb_alloc_color_planes_reply_t * xcb_alloc_color_planes_reply 12574 ** 12575 ** @param xcb_connection_t *c 12576 ** @param xcb_alloc_color_planes_cookie_t cookie 12577 ** @param xcb_generic_error_t **e 12578 ** @returns xcb_alloc_color_planes_reply_t * 12579 ** 12580 *****************************************************************************/ 12581 12582 xcb_alloc_color_planes_reply_t * 12583 xcb_alloc_color_planes_reply (xcb_connection_t *c /**< */, 12584 xcb_alloc_color_planes_cookie_t cookie /**< */, 12585 xcb_generic_error_t **e /**< */) 12586 { 12587 return (xcb_alloc_color_planes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 12588 } 12589 12590 int 12591 xcb_free_colors_sizeof (const void *_buffer /**< */, 12592 uint32_t pixels_len /**< */) 12593 { 12594 char *xcb_tmp = (char *)_buffer; 12595 unsigned int xcb_buffer_len = 0; 12596 unsigned int xcb_block_len = 0; 12597 unsigned int xcb_pad = 0; 12598 unsigned int xcb_align_to; 12599 12600 12601 xcb_block_len += sizeof(xcb_free_colors_request_t); 12602 xcb_tmp += xcb_block_len; 12603 /* pixels */ 12604 xcb_block_len += pixels_len * sizeof(uint32_t); 12605 xcb_tmp += xcb_block_len; 12606 xcb_align_to = ALIGNOF(uint32_t); 12607 /* insert padding */ 12608 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12609 xcb_buffer_len += xcb_block_len + xcb_pad; 12610 if (0 != xcb_pad) { 12611 xcb_tmp += xcb_pad; 12612 xcb_pad = 0; 12613 } 12614 xcb_block_len = 0; 12615 12616 return xcb_buffer_len; 12617 } 12618 12619 12620 /***************************************************************************** 12621 ** 12622 ** xcb_void_cookie_t xcb_free_colors_checked 12623 ** 12624 ** @param xcb_connection_t *c 12625 ** @param xcb_colormap_t cmap 12626 ** @param uint32_t plane_mask 12627 ** @param uint32_t pixels_len 12628 ** @param const uint32_t *pixels 12629 ** @returns xcb_void_cookie_t 12630 ** 12631 *****************************************************************************/ 12632 12633 xcb_void_cookie_t 12634 xcb_free_colors_checked (xcb_connection_t *c /**< */, 12635 xcb_colormap_t cmap /**< */, 12636 uint32_t plane_mask /**< */, 12637 uint32_t pixels_len /**< */, 12638 const uint32_t *pixels /**< */) 12639 { 12640 static const xcb_protocol_request_t xcb_req = { 12641 /* count */ 4, 12642 /* ext */ 0, 12643 /* opcode */ XCB_FREE_COLORS, 12644 /* isvoid */ 1 12645 }; 12646 12647 struct iovec xcb_parts[6]; 12648 xcb_void_cookie_t xcb_ret; 12649 xcb_free_colors_request_t xcb_out; 12650 12651 xcb_out.pad0 = 0; 12652 xcb_out.cmap = cmap; 12653 xcb_out.plane_mask = plane_mask; 12654 12655 xcb_parts[2].iov_base = (char *) &xcb_out; 12656 xcb_parts[2].iov_len = sizeof(xcb_out); 12657 xcb_parts[3].iov_base = 0; 12658 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12659 /* uint32_t pixels */ 12660 xcb_parts[4].iov_base = (char *) pixels; 12661 xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t); 12662 xcb_parts[5].iov_base = 0; 12663 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12664 12665 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12666 return xcb_ret; 12667 } 12668 12669 12670 /***************************************************************************** 12671 ** 12672 ** xcb_void_cookie_t xcb_free_colors 12673 ** 12674 ** @param xcb_connection_t *c 12675 ** @param xcb_colormap_t cmap 12676 ** @param uint32_t plane_mask 12677 ** @param uint32_t pixels_len 12678 ** @param const uint32_t *pixels 12679 ** @returns xcb_void_cookie_t 12680 ** 12681 *****************************************************************************/ 12682 12683 xcb_void_cookie_t 12684 xcb_free_colors (xcb_connection_t *c /**< */, 12685 xcb_colormap_t cmap /**< */, 12686 uint32_t plane_mask /**< */, 12687 uint32_t pixels_len /**< */, 12688 const uint32_t *pixels /**< */) 12689 { 12690 static const xcb_protocol_request_t xcb_req = { 12691 /* count */ 4, 12692 /* ext */ 0, 12693 /* opcode */ XCB_FREE_COLORS, 12694 /* isvoid */ 1 12695 }; 12696 12697 struct iovec xcb_parts[6]; 12698 xcb_void_cookie_t xcb_ret; 12699 xcb_free_colors_request_t xcb_out; 12700 12701 xcb_out.pad0 = 0; 12702 xcb_out.cmap = cmap; 12703 xcb_out.plane_mask = plane_mask; 12704 12705 xcb_parts[2].iov_base = (char *) &xcb_out; 12706 xcb_parts[2].iov_len = sizeof(xcb_out); 12707 xcb_parts[3].iov_base = 0; 12708 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12709 /* uint32_t pixels */ 12710 xcb_parts[4].iov_base = (char *) pixels; 12711 xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t); 12712 xcb_parts[5].iov_base = 0; 12713 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12714 12715 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12716 return xcb_ret; 12717 } 12718 12719 12720 /***************************************************************************** 12721 ** 12722 ** void xcb_coloritem_next 12723 ** 12724 ** @param xcb_coloritem_iterator_t *i 12725 ** @returns void 12726 ** 12727 *****************************************************************************/ 12728 12729 void 12730 xcb_coloritem_next (xcb_coloritem_iterator_t *i /**< */) 12731 { 12732 --i->rem; 12733 ++i->data; 12734 i->index += sizeof(xcb_coloritem_t); 12735 } 12736 12737 12738 /***************************************************************************** 12739 ** 12740 ** xcb_generic_iterator_t xcb_coloritem_end 12741 ** 12742 ** @param xcb_coloritem_iterator_t i 12743 ** @returns xcb_generic_iterator_t 12744 ** 12745 *****************************************************************************/ 12746 12747 xcb_generic_iterator_t 12748 xcb_coloritem_end (xcb_coloritem_iterator_t i /**< */) 12749 { 12750 xcb_generic_iterator_t ret; 12751 ret.data = i.data + i.rem; 12752 ret.index = i.index + ((char *) ret.data - (char *) i.data); 12753 ret.rem = 0; 12754 return ret; 12755 } 12756 12757 int 12758 xcb_store_colors_sizeof (const void *_buffer /**< */, 12759 uint32_t items_len /**< */) 12760 { 12761 char *xcb_tmp = (char *)_buffer; 12762 unsigned int xcb_buffer_len = 0; 12763 unsigned int xcb_block_len = 0; 12764 unsigned int xcb_pad = 0; 12765 unsigned int xcb_align_to; 12766 12767 12768 xcb_block_len += sizeof(xcb_store_colors_request_t); 12769 xcb_tmp += xcb_block_len; 12770 /* items */ 12771 xcb_block_len += items_len * sizeof(xcb_coloritem_t); 12772 xcb_tmp += xcb_block_len; 12773 xcb_align_to = ALIGNOF(xcb_coloritem_t); 12774 /* insert padding */ 12775 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12776 xcb_buffer_len += xcb_block_len + xcb_pad; 12777 if (0 != xcb_pad) { 12778 xcb_tmp += xcb_pad; 12779 xcb_pad = 0; 12780 } 12781 xcb_block_len = 0; 12782 12783 return xcb_buffer_len; 12784 } 12785 12786 12787 /***************************************************************************** 12788 ** 12789 ** xcb_void_cookie_t xcb_store_colors_checked 12790 ** 12791 ** @param xcb_connection_t *c 12792 ** @param xcb_colormap_t cmap 12793 ** @param uint32_t items_len 12794 ** @param const xcb_coloritem_t *items 12795 ** @returns xcb_void_cookie_t 12796 ** 12797 *****************************************************************************/ 12798 12799 xcb_void_cookie_t 12800 xcb_store_colors_checked (xcb_connection_t *c /**< */, 12801 xcb_colormap_t cmap /**< */, 12802 uint32_t items_len /**< */, 12803 const xcb_coloritem_t *items /**< */) 12804 { 12805 static const xcb_protocol_request_t xcb_req = { 12806 /* count */ 4, 12807 /* ext */ 0, 12808 /* opcode */ XCB_STORE_COLORS, 12809 /* isvoid */ 1 12810 }; 12811 12812 struct iovec xcb_parts[6]; 12813 xcb_void_cookie_t xcb_ret; 12814 xcb_store_colors_request_t xcb_out; 12815 12816 xcb_out.pad0 = 0; 12817 xcb_out.cmap = cmap; 12818 12819 xcb_parts[2].iov_base = (char *) &xcb_out; 12820 xcb_parts[2].iov_len = sizeof(xcb_out); 12821 xcb_parts[3].iov_base = 0; 12822 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12823 /* xcb_coloritem_t items */ 12824 xcb_parts[4].iov_base = (char *) items; 12825 xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t); 12826 xcb_parts[5].iov_base = 0; 12827 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12828 12829 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12830 return xcb_ret; 12831 } 12832 12833 12834 /***************************************************************************** 12835 ** 12836 ** xcb_void_cookie_t xcb_store_colors 12837 ** 12838 ** @param xcb_connection_t *c 12839 ** @param xcb_colormap_t cmap 12840 ** @param uint32_t items_len 12841 ** @param const xcb_coloritem_t *items 12842 ** @returns xcb_void_cookie_t 12843 ** 12844 *****************************************************************************/ 12845 12846 xcb_void_cookie_t 12847 xcb_store_colors (xcb_connection_t *c /**< */, 12848 xcb_colormap_t cmap /**< */, 12849 uint32_t items_len /**< */, 12850 const xcb_coloritem_t *items /**< */) 12851 { 12852 static const xcb_protocol_request_t xcb_req = { 12853 /* count */ 4, 12854 /* ext */ 0, 12855 /* opcode */ XCB_STORE_COLORS, 12856 /* isvoid */ 1 12857 }; 12858 12859 struct iovec xcb_parts[6]; 12860 xcb_void_cookie_t xcb_ret; 12861 xcb_store_colors_request_t xcb_out; 12862 12863 xcb_out.pad0 = 0; 12864 xcb_out.cmap = cmap; 12865 12866 xcb_parts[2].iov_base = (char *) &xcb_out; 12867 xcb_parts[2].iov_len = sizeof(xcb_out); 12868 xcb_parts[3].iov_base = 0; 12869 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12870 /* xcb_coloritem_t items */ 12871 xcb_parts[4].iov_base = (char *) items; 12872 xcb_parts[4].iov_len = items_len * sizeof(xcb_coloritem_t); 12873 xcb_parts[5].iov_base = 0; 12874 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12875 12876 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 12877 return xcb_ret; 12878 } 12879 12880 int 12881 xcb_store_named_color_sizeof (const void *_buffer /**< */) 12882 { 12883 char *xcb_tmp = (char *)_buffer; 12884 const xcb_store_named_color_request_t *_aux = (xcb_store_named_color_request_t *)_buffer; 12885 unsigned int xcb_buffer_len = 0; 12886 unsigned int xcb_block_len = 0; 12887 unsigned int xcb_pad = 0; 12888 unsigned int xcb_align_to; 12889 12890 12891 xcb_block_len += sizeof(xcb_store_named_color_request_t); 12892 xcb_tmp += xcb_block_len; 12893 /* name */ 12894 xcb_block_len += _aux->name_len * sizeof(char); 12895 xcb_tmp += xcb_block_len; 12896 xcb_align_to = ALIGNOF(char); 12897 /* insert padding */ 12898 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 12899 xcb_buffer_len += xcb_block_len + xcb_pad; 12900 if (0 != xcb_pad) { 12901 xcb_tmp += xcb_pad; 12902 xcb_pad = 0; 12903 } 12904 xcb_block_len = 0; 12905 12906 return xcb_buffer_len; 12907 } 12908 12909 12910 /***************************************************************************** 12911 ** 12912 ** xcb_void_cookie_t xcb_store_named_color_checked 12913 ** 12914 ** @param xcb_connection_t *c 12915 ** @param uint8_t flags 12916 ** @param xcb_colormap_t cmap 12917 ** @param uint32_t pixel 12918 ** @param uint16_t name_len 12919 ** @param const char *name 12920 ** @returns xcb_void_cookie_t 12921 ** 12922 *****************************************************************************/ 12923 12924 xcb_void_cookie_t 12925 xcb_store_named_color_checked (xcb_connection_t *c /**< */, 12926 uint8_t flags /**< */, 12927 xcb_colormap_t cmap /**< */, 12928 uint32_t pixel /**< */, 12929 uint16_t name_len /**< */, 12930 const char *name /**< */) 12931 { 12932 static const xcb_protocol_request_t xcb_req = { 12933 /* count */ 4, 12934 /* ext */ 0, 12935 /* opcode */ XCB_STORE_NAMED_COLOR, 12936 /* isvoid */ 1 12937 }; 12938 12939 struct iovec xcb_parts[6]; 12940 xcb_void_cookie_t xcb_ret; 12941 xcb_store_named_color_request_t xcb_out; 12942 12943 xcb_out.flags = flags; 12944 xcb_out.cmap = cmap; 12945 xcb_out.pixel = pixel; 12946 xcb_out.name_len = name_len; 12947 memset(xcb_out.pad0, 0, 2); 12948 12949 xcb_parts[2].iov_base = (char *) &xcb_out; 12950 xcb_parts[2].iov_len = sizeof(xcb_out); 12951 xcb_parts[3].iov_base = 0; 12952 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 12953 /* char name */ 12954 xcb_parts[4].iov_base = (char *) name; 12955 xcb_parts[4].iov_len = name_len * sizeof(char); 12956 xcb_parts[5].iov_base = 0; 12957 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 12958 12959 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 12960 return xcb_ret; 12961 } 12962 12963 12964 /***************************************************************************** 12965 ** 12966 ** xcb_void_cookie_t xcb_store_named_color 12967 ** 12968 ** @param xcb_connection_t *c 12969 ** @param uint8_t flags 12970 ** @param xcb_colormap_t cmap 12971 ** @param uint32_t pixel 12972 ** @param uint16_t name_len 12973 ** @param const char *name 12974 ** @returns xcb_void_cookie_t 12975 ** 12976 *****************************************************************************/ 12977 12978 xcb_void_cookie_t 12979 xcb_store_named_color (xcb_connection_t *c /**< */, 12980 uint8_t flags /**< */, 12981 xcb_colormap_t cmap /**< */, 12982 uint32_t pixel /**< */, 12983 uint16_t name_len /**< */, 12984 const char *name /**< */) 12985 { 12986 static const xcb_protocol_request_t xcb_req = { 12987 /* count */ 4, 12988 /* ext */ 0, 12989 /* opcode */ XCB_STORE_NAMED_COLOR, 12990 /* isvoid */ 1 12991 }; 12992 12993 struct iovec xcb_parts[6]; 12994 xcb_void_cookie_t xcb_ret; 12995 xcb_store_named_color_request_t xcb_out; 12996 12997 xcb_out.flags = flags; 12998 xcb_out.cmap = cmap; 12999 xcb_out.pixel = pixel; 13000 xcb_out.name_len = name_len; 13001 memset(xcb_out.pad0, 0, 2); 13002 13003 xcb_parts[2].iov_base = (char *) &xcb_out; 13004 xcb_parts[2].iov_len = sizeof(xcb_out); 13005 xcb_parts[3].iov_base = 0; 13006 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13007 /* char name */ 13008 xcb_parts[4].iov_base = (char *) name; 13009 xcb_parts[4].iov_len = name_len * sizeof(char); 13010 xcb_parts[5].iov_base = 0; 13011 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 13012 13013 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13014 return xcb_ret; 13015 } 13016 13017 13018 /***************************************************************************** 13019 ** 13020 ** void xcb_rgb_next 13021 ** 13022 ** @param xcb_rgb_iterator_t *i 13023 ** @returns void 13024 ** 13025 *****************************************************************************/ 13026 13027 void 13028 xcb_rgb_next (xcb_rgb_iterator_t *i /**< */) 13029 { 13030 --i->rem; 13031 ++i->data; 13032 i->index += sizeof(xcb_rgb_t); 13033 } 13034 13035 13036 /***************************************************************************** 13037 ** 13038 ** xcb_generic_iterator_t xcb_rgb_end 13039 ** 13040 ** @param xcb_rgb_iterator_t i 13041 ** @returns xcb_generic_iterator_t 13042 ** 13043 *****************************************************************************/ 13044 13045 xcb_generic_iterator_t 13046 xcb_rgb_end (xcb_rgb_iterator_t i /**< */) 13047 { 13048 xcb_generic_iterator_t ret; 13049 ret.data = i.data + i.rem; 13050 ret.index = i.index + ((char *) ret.data - (char *) i.data); 13051 ret.rem = 0; 13052 return ret; 13053 } 13054 13055 int 13056 xcb_query_colors_sizeof (const void *_buffer /**< */, 13057 uint32_t pixels_len /**< */) 13058 { 13059 char *xcb_tmp = (char *)_buffer; 13060 unsigned int xcb_buffer_len = 0; 13061 unsigned int xcb_block_len = 0; 13062 unsigned int xcb_pad = 0; 13063 unsigned int xcb_align_to; 13064 13065 13066 xcb_block_len += sizeof(xcb_query_colors_request_t); 13067 xcb_tmp += xcb_block_len; 13068 /* pixels */ 13069 xcb_block_len += pixels_len * sizeof(uint32_t); 13070 xcb_tmp += xcb_block_len; 13071 xcb_align_to = ALIGNOF(uint32_t); 13072 /* insert padding */ 13073 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13074 xcb_buffer_len += xcb_block_len + xcb_pad; 13075 if (0 != xcb_pad) { 13076 xcb_tmp += xcb_pad; 13077 xcb_pad = 0; 13078 } 13079 xcb_block_len = 0; 13080 13081 return xcb_buffer_len; 13082 } 13083 13084 13085 /***************************************************************************** 13086 ** 13087 ** xcb_query_colors_cookie_t xcb_query_colors 13088 ** 13089 ** @param xcb_connection_t *c 13090 ** @param xcb_colormap_t cmap 13091 ** @param uint32_t pixels_len 13092 ** @param const uint32_t *pixels 13093 ** @returns xcb_query_colors_cookie_t 13094 ** 13095 *****************************************************************************/ 13096 13097 xcb_query_colors_cookie_t 13098 xcb_query_colors (xcb_connection_t *c /**< */, 13099 xcb_colormap_t cmap /**< */, 13100 uint32_t pixels_len /**< */, 13101 const uint32_t *pixels /**< */) 13102 { 13103 static const xcb_protocol_request_t xcb_req = { 13104 /* count */ 4, 13105 /* ext */ 0, 13106 /* opcode */ XCB_QUERY_COLORS, 13107 /* isvoid */ 0 13108 }; 13109 13110 struct iovec xcb_parts[6]; 13111 xcb_query_colors_cookie_t xcb_ret; 13112 xcb_query_colors_request_t xcb_out; 13113 13114 xcb_out.pad0 = 0; 13115 xcb_out.cmap = cmap; 13116 13117 xcb_parts[2].iov_base = (char *) &xcb_out; 13118 xcb_parts[2].iov_len = sizeof(xcb_out); 13119 xcb_parts[3].iov_base = 0; 13120 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13121 /* uint32_t pixels */ 13122 xcb_parts[4].iov_base = (char *) pixels; 13123 xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t); 13124 xcb_parts[5].iov_base = 0; 13125 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 13126 13127 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13128 return xcb_ret; 13129 } 13130 13131 13132 /***************************************************************************** 13133 ** 13134 ** xcb_query_colors_cookie_t xcb_query_colors_unchecked 13135 ** 13136 ** @param xcb_connection_t *c 13137 ** @param xcb_colormap_t cmap 13138 ** @param uint32_t pixels_len 13139 ** @param const uint32_t *pixels 13140 ** @returns xcb_query_colors_cookie_t 13141 ** 13142 *****************************************************************************/ 13143 13144 xcb_query_colors_cookie_t 13145 xcb_query_colors_unchecked (xcb_connection_t *c /**< */, 13146 xcb_colormap_t cmap /**< */, 13147 uint32_t pixels_len /**< */, 13148 const uint32_t *pixels /**< */) 13149 { 13150 static const xcb_protocol_request_t xcb_req = { 13151 /* count */ 4, 13152 /* ext */ 0, 13153 /* opcode */ XCB_QUERY_COLORS, 13154 /* isvoid */ 0 13155 }; 13156 13157 struct iovec xcb_parts[6]; 13158 xcb_query_colors_cookie_t xcb_ret; 13159 xcb_query_colors_request_t xcb_out; 13160 13161 xcb_out.pad0 = 0; 13162 xcb_out.cmap = cmap; 13163 13164 xcb_parts[2].iov_base = (char *) &xcb_out; 13165 xcb_parts[2].iov_len = sizeof(xcb_out); 13166 xcb_parts[3].iov_base = 0; 13167 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13168 /* uint32_t pixels */ 13169 xcb_parts[4].iov_base = (char *) pixels; 13170 xcb_parts[4].iov_len = pixels_len * sizeof(uint32_t); 13171 xcb_parts[5].iov_base = 0; 13172 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 13173 13174 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13175 return xcb_ret; 13176 } 13177 13178 13179 /***************************************************************************** 13180 ** 13181 ** xcb_rgb_t * xcb_query_colors_colors 13182 ** 13183 ** @param const xcb_query_colors_reply_t *R 13184 ** @returns xcb_rgb_t * 13185 ** 13186 *****************************************************************************/ 13187 13188 xcb_rgb_t * 13189 xcb_query_colors_colors (const xcb_query_colors_reply_t *R /**< */) 13190 { 13191 return (xcb_rgb_t *) (R + 1); 13192 } 13193 13194 13195 /***************************************************************************** 13196 ** 13197 ** int xcb_query_colors_colors_length 13198 ** 13199 ** @param const xcb_query_colors_reply_t *R 13200 ** @returns int 13201 ** 13202 *****************************************************************************/ 13203 13204 int 13205 xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R /**< */) 13206 { 13207 return R->colors_len; 13208 } 13209 13210 13211 /***************************************************************************** 13212 ** 13213 ** xcb_rgb_iterator_t xcb_query_colors_colors_iterator 13214 ** 13215 ** @param const xcb_query_colors_reply_t *R 13216 ** @returns xcb_rgb_iterator_t 13217 ** 13218 *****************************************************************************/ 13219 13220 xcb_rgb_iterator_t 13221 xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R /**< */) 13222 { 13223 xcb_rgb_iterator_t i; 13224 i.data = (xcb_rgb_t *) (R + 1); 13225 i.rem = R->colors_len; 13226 i.index = (char *) i.data - (char *) R; 13227 return i; 13228 } 13229 13230 13231 /***************************************************************************** 13232 ** 13233 ** xcb_query_colors_reply_t * xcb_query_colors_reply 13234 ** 13235 ** @param xcb_connection_t *c 13236 ** @param xcb_query_colors_cookie_t cookie 13237 ** @param xcb_generic_error_t **e 13238 ** @returns xcb_query_colors_reply_t * 13239 ** 13240 *****************************************************************************/ 13241 13242 xcb_query_colors_reply_t * 13243 xcb_query_colors_reply (xcb_connection_t *c /**< */, 13244 xcb_query_colors_cookie_t cookie /**< */, 13245 xcb_generic_error_t **e /**< */) 13246 { 13247 return (xcb_query_colors_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13248 } 13249 13250 int 13251 xcb_lookup_color_sizeof (const void *_buffer /**< */) 13252 { 13253 char *xcb_tmp = (char *)_buffer; 13254 const xcb_lookup_color_request_t *_aux = (xcb_lookup_color_request_t *)_buffer; 13255 unsigned int xcb_buffer_len = 0; 13256 unsigned int xcb_block_len = 0; 13257 unsigned int xcb_pad = 0; 13258 unsigned int xcb_align_to; 13259 13260 13261 xcb_block_len += sizeof(xcb_lookup_color_request_t); 13262 xcb_tmp += xcb_block_len; 13263 /* name */ 13264 xcb_block_len += _aux->name_len * sizeof(char); 13265 xcb_tmp += xcb_block_len; 13266 xcb_align_to = ALIGNOF(char); 13267 /* insert padding */ 13268 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13269 xcb_buffer_len += xcb_block_len + xcb_pad; 13270 if (0 != xcb_pad) { 13271 xcb_tmp += xcb_pad; 13272 xcb_pad = 0; 13273 } 13274 xcb_block_len = 0; 13275 13276 return xcb_buffer_len; 13277 } 13278 13279 13280 /***************************************************************************** 13281 ** 13282 ** xcb_lookup_color_cookie_t xcb_lookup_color 13283 ** 13284 ** @param xcb_connection_t *c 13285 ** @param xcb_colormap_t cmap 13286 ** @param uint16_t name_len 13287 ** @param const char *name 13288 ** @returns xcb_lookup_color_cookie_t 13289 ** 13290 *****************************************************************************/ 13291 13292 xcb_lookup_color_cookie_t 13293 xcb_lookup_color (xcb_connection_t *c /**< */, 13294 xcb_colormap_t cmap /**< */, 13295 uint16_t name_len /**< */, 13296 const char *name /**< */) 13297 { 13298 static const xcb_protocol_request_t xcb_req = { 13299 /* count */ 4, 13300 /* ext */ 0, 13301 /* opcode */ XCB_LOOKUP_COLOR, 13302 /* isvoid */ 0 13303 }; 13304 13305 struct iovec xcb_parts[6]; 13306 xcb_lookup_color_cookie_t xcb_ret; 13307 xcb_lookup_color_request_t xcb_out; 13308 13309 xcb_out.pad0 = 0; 13310 xcb_out.cmap = cmap; 13311 xcb_out.name_len = name_len; 13312 memset(xcb_out.pad1, 0, 2); 13313 13314 xcb_parts[2].iov_base = (char *) &xcb_out; 13315 xcb_parts[2].iov_len = sizeof(xcb_out); 13316 xcb_parts[3].iov_base = 0; 13317 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13318 /* char name */ 13319 xcb_parts[4].iov_base = (char *) name; 13320 xcb_parts[4].iov_len = name_len * sizeof(char); 13321 xcb_parts[5].iov_base = 0; 13322 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 13323 13324 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13325 return xcb_ret; 13326 } 13327 13328 13329 /***************************************************************************** 13330 ** 13331 ** xcb_lookup_color_cookie_t xcb_lookup_color_unchecked 13332 ** 13333 ** @param xcb_connection_t *c 13334 ** @param xcb_colormap_t cmap 13335 ** @param uint16_t name_len 13336 ** @param const char *name 13337 ** @returns xcb_lookup_color_cookie_t 13338 ** 13339 *****************************************************************************/ 13340 13341 xcb_lookup_color_cookie_t 13342 xcb_lookup_color_unchecked (xcb_connection_t *c /**< */, 13343 xcb_colormap_t cmap /**< */, 13344 uint16_t name_len /**< */, 13345 const char *name /**< */) 13346 { 13347 static const xcb_protocol_request_t xcb_req = { 13348 /* count */ 4, 13349 /* ext */ 0, 13350 /* opcode */ XCB_LOOKUP_COLOR, 13351 /* isvoid */ 0 13352 }; 13353 13354 struct iovec xcb_parts[6]; 13355 xcb_lookup_color_cookie_t xcb_ret; 13356 xcb_lookup_color_request_t xcb_out; 13357 13358 xcb_out.pad0 = 0; 13359 xcb_out.cmap = cmap; 13360 xcb_out.name_len = name_len; 13361 memset(xcb_out.pad1, 0, 2); 13362 13363 xcb_parts[2].iov_base = (char *) &xcb_out; 13364 xcb_parts[2].iov_len = sizeof(xcb_out); 13365 xcb_parts[3].iov_base = 0; 13366 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13367 /* char name */ 13368 xcb_parts[4].iov_base = (char *) name; 13369 xcb_parts[4].iov_len = name_len * sizeof(char); 13370 xcb_parts[5].iov_base = 0; 13371 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 13372 13373 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13374 return xcb_ret; 13375 } 13376 13377 13378 /***************************************************************************** 13379 ** 13380 ** xcb_lookup_color_reply_t * xcb_lookup_color_reply 13381 ** 13382 ** @param xcb_connection_t *c 13383 ** @param xcb_lookup_color_cookie_t cookie 13384 ** @param xcb_generic_error_t **e 13385 ** @returns xcb_lookup_color_reply_t * 13386 ** 13387 *****************************************************************************/ 13388 13389 xcb_lookup_color_reply_t * 13390 xcb_lookup_color_reply (xcb_connection_t *c /**< */, 13391 xcb_lookup_color_cookie_t cookie /**< */, 13392 xcb_generic_error_t **e /**< */) 13393 { 13394 return (xcb_lookup_color_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13395 } 13396 13397 13398 /***************************************************************************** 13399 ** 13400 ** xcb_void_cookie_t xcb_create_cursor_checked 13401 ** 13402 ** @param xcb_connection_t *c 13403 ** @param xcb_cursor_t cid 13404 ** @param xcb_pixmap_t source 13405 ** @param xcb_pixmap_t mask 13406 ** @param uint16_t fore_red 13407 ** @param uint16_t fore_green 13408 ** @param uint16_t fore_blue 13409 ** @param uint16_t back_red 13410 ** @param uint16_t back_green 13411 ** @param uint16_t back_blue 13412 ** @param uint16_t x 13413 ** @param uint16_t y 13414 ** @returns xcb_void_cookie_t 13415 ** 13416 *****************************************************************************/ 13417 13418 xcb_void_cookie_t 13419 xcb_create_cursor_checked (xcb_connection_t *c /**< */, 13420 xcb_cursor_t cid /**< */, 13421 xcb_pixmap_t source /**< */, 13422 xcb_pixmap_t mask /**< */, 13423 uint16_t fore_red /**< */, 13424 uint16_t fore_green /**< */, 13425 uint16_t fore_blue /**< */, 13426 uint16_t back_red /**< */, 13427 uint16_t back_green /**< */, 13428 uint16_t back_blue /**< */, 13429 uint16_t x /**< */, 13430 uint16_t y /**< */) 13431 { 13432 static const xcb_protocol_request_t xcb_req = { 13433 /* count */ 2, 13434 /* ext */ 0, 13435 /* opcode */ XCB_CREATE_CURSOR, 13436 /* isvoid */ 1 13437 }; 13438 13439 struct iovec xcb_parts[4]; 13440 xcb_void_cookie_t xcb_ret; 13441 xcb_create_cursor_request_t xcb_out; 13442 13443 xcb_out.pad0 = 0; 13444 xcb_out.cid = cid; 13445 xcb_out.source = source; 13446 xcb_out.mask = mask; 13447 xcb_out.fore_red = fore_red; 13448 xcb_out.fore_green = fore_green; 13449 xcb_out.fore_blue = fore_blue; 13450 xcb_out.back_red = back_red; 13451 xcb_out.back_green = back_green; 13452 xcb_out.back_blue = back_blue; 13453 xcb_out.x = x; 13454 xcb_out.y = y; 13455 13456 xcb_parts[2].iov_base = (char *) &xcb_out; 13457 xcb_parts[2].iov_len = sizeof(xcb_out); 13458 xcb_parts[3].iov_base = 0; 13459 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13460 13461 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13462 return xcb_ret; 13463 } 13464 13465 13466 /***************************************************************************** 13467 ** 13468 ** xcb_void_cookie_t xcb_create_cursor 13469 ** 13470 ** @param xcb_connection_t *c 13471 ** @param xcb_cursor_t cid 13472 ** @param xcb_pixmap_t source 13473 ** @param xcb_pixmap_t mask 13474 ** @param uint16_t fore_red 13475 ** @param uint16_t fore_green 13476 ** @param uint16_t fore_blue 13477 ** @param uint16_t back_red 13478 ** @param uint16_t back_green 13479 ** @param uint16_t back_blue 13480 ** @param uint16_t x 13481 ** @param uint16_t y 13482 ** @returns xcb_void_cookie_t 13483 ** 13484 *****************************************************************************/ 13485 13486 xcb_void_cookie_t 13487 xcb_create_cursor (xcb_connection_t *c /**< */, 13488 xcb_cursor_t cid /**< */, 13489 xcb_pixmap_t source /**< */, 13490 xcb_pixmap_t mask /**< */, 13491 uint16_t fore_red /**< */, 13492 uint16_t fore_green /**< */, 13493 uint16_t fore_blue /**< */, 13494 uint16_t back_red /**< */, 13495 uint16_t back_green /**< */, 13496 uint16_t back_blue /**< */, 13497 uint16_t x /**< */, 13498 uint16_t y /**< */) 13499 { 13500 static const xcb_protocol_request_t xcb_req = { 13501 /* count */ 2, 13502 /* ext */ 0, 13503 /* opcode */ XCB_CREATE_CURSOR, 13504 /* isvoid */ 1 13505 }; 13506 13507 struct iovec xcb_parts[4]; 13508 xcb_void_cookie_t xcb_ret; 13509 xcb_create_cursor_request_t xcb_out; 13510 13511 xcb_out.pad0 = 0; 13512 xcb_out.cid = cid; 13513 xcb_out.source = source; 13514 xcb_out.mask = mask; 13515 xcb_out.fore_red = fore_red; 13516 xcb_out.fore_green = fore_green; 13517 xcb_out.fore_blue = fore_blue; 13518 xcb_out.back_red = back_red; 13519 xcb_out.back_green = back_green; 13520 xcb_out.back_blue = back_blue; 13521 xcb_out.x = x; 13522 xcb_out.y = y; 13523 13524 xcb_parts[2].iov_base = (char *) &xcb_out; 13525 xcb_parts[2].iov_len = sizeof(xcb_out); 13526 xcb_parts[3].iov_base = 0; 13527 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13528 13529 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13530 return xcb_ret; 13531 } 13532 13533 13534 /***************************************************************************** 13535 ** 13536 ** xcb_void_cookie_t xcb_create_glyph_cursor_checked 13537 ** 13538 ** @param xcb_connection_t *c 13539 ** @param xcb_cursor_t cid 13540 ** @param xcb_font_t source_font 13541 ** @param xcb_font_t mask_font 13542 ** @param uint16_t source_char 13543 ** @param uint16_t mask_char 13544 ** @param uint16_t fore_red 13545 ** @param uint16_t fore_green 13546 ** @param uint16_t fore_blue 13547 ** @param uint16_t back_red 13548 ** @param uint16_t back_green 13549 ** @param uint16_t back_blue 13550 ** @returns xcb_void_cookie_t 13551 ** 13552 *****************************************************************************/ 13553 13554 xcb_void_cookie_t 13555 xcb_create_glyph_cursor_checked (xcb_connection_t *c /**< */, 13556 xcb_cursor_t cid /**< */, 13557 xcb_font_t source_font /**< */, 13558 xcb_font_t mask_font /**< */, 13559 uint16_t source_char /**< */, 13560 uint16_t mask_char /**< */, 13561 uint16_t fore_red /**< */, 13562 uint16_t fore_green /**< */, 13563 uint16_t fore_blue /**< */, 13564 uint16_t back_red /**< */, 13565 uint16_t back_green /**< */, 13566 uint16_t back_blue /**< */) 13567 { 13568 static const xcb_protocol_request_t xcb_req = { 13569 /* count */ 2, 13570 /* ext */ 0, 13571 /* opcode */ XCB_CREATE_GLYPH_CURSOR, 13572 /* isvoid */ 1 13573 }; 13574 13575 struct iovec xcb_parts[4]; 13576 xcb_void_cookie_t xcb_ret; 13577 xcb_create_glyph_cursor_request_t xcb_out; 13578 13579 xcb_out.pad0 = 0; 13580 xcb_out.cid = cid; 13581 xcb_out.source_font = source_font; 13582 xcb_out.mask_font = mask_font; 13583 xcb_out.source_char = source_char; 13584 xcb_out.mask_char = mask_char; 13585 xcb_out.fore_red = fore_red; 13586 xcb_out.fore_green = fore_green; 13587 xcb_out.fore_blue = fore_blue; 13588 xcb_out.back_red = back_red; 13589 xcb_out.back_green = back_green; 13590 xcb_out.back_blue = back_blue; 13591 13592 xcb_parts[2].iov_base = (char *) &xcb_out; 13593 xcb_parts[2].iov_len = sizeof(xcb_out); 13594 xcb_parts[3].iov_base = 0; 13595 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13596 13597 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13598 return xcb_ret; 13599 } 13600 13601 13602 /***************************************************************************** 13603 ** 13604 ** xcb_void_cookie_t xcb_create_glyph_cursor 13605 ** 13606 ** @param xcb_connection_t *c 13607 ** @param xcb_cursor_t cid 13608 ** @param xcb_font_t source_font 13609 ** @param xcb_font_t mask_font 13610 ** @param uint16_t source_char 13611 ** @param uint16_t mask_char 13612 ** @param uint16_t fore_red 13613 ** @param uint16_t fore_green 13614 ** @param uint16_t fore_blue 13615 ** @param uint16_t back_red 13616 ** @param uint16_t back_green 13617 ** @param uint16_t back_blue 13618 ** @returns xcb_void_cookie_t 13619 ** 13620 *****************************************************************************/ 13621 13622 xcb_void_cookie_t 13623 xcb_create_glyph_cursor (xcb_connection_t *c /**< */, 13624 xcb_cursor_t cid /**< */, 13625 xcb_font_t source_font /**< */, 13626 xcb_font_t mask_font /**< */, 13627 uint16_t source_char /**< */, 13628 uint16_t mask_char /**< */, 13629 uint16_t fore_red /**< */, 13630 uint16_t fore_green /**< */, 13631 uint16_t fore_blue /**< */, 13632 uint16_t back_red /**< */, 13633 uint16_t back_green /**< */, 13634 uint16_t back_blue /**< */) 13635 { 13636 static const xcb_protocol_request_t xcb_req = { 13637 /* count */ 2, 13638 /* ext */ 0, 13639 /* opcode */ XCB_CREATE_GLYPH_CURSOR, 13640 /* isvoid */ 1 13641 }; 13642 13643 struct iovec xcb_parts[4]; 13644 xcb_void_cookie_t xcb_ret; 13645 xcb_create_glyph_cursor_request_t xcb_out; 13646 13647 xcb_out.pad0 = 0; 13648 xcb_out.cid = cid; 13649 xcb_out.source_font = source_font; 13650 xcb_out.mask_font = mask_font; 13651 xcb_out.source_char = source_char; 13652 xcb_out.mask_char = mask_char; 13653 xcb_out.fore_red = fore_red; 13654 xcb_out.fore_green = fore_green; 13655 xcb_out.fore_blue = fore_blue; 13656 xcb_out.back_red = back_red; 13657 xcb_out.back_green = back_green; 13658 xcb_out.back_blue = back_blue; 13659 13660 xcb_parts[2].iov_base = (char *) &xcb_out; 13661 xcb_parts[2].iov_len = sizeof(xcb_out); 13662 xcb_parts[3].iov_base = 0; 13663 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13664 13665 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13666 return xcb_ret; 13667 } 13668 13669 13670 /***************************************************************************** 13671 ** 13672 ** xcb_void_cookie_t xcb_free_cursor_checked 13673 ** 13674 ** @param xcb_connection_t *c 13675 ** @param xcb_cursor_t cursor 13676 ** @returns xcb_void_cookie_t 13677 ** 13678 *****************************************************************************/ 13679 13680 xcb_void_cookie_t 13681 xcb_free_cursor_checked (xcb_connection_t *c /**< */, 13682 xcb_cursor_t cursor /**< */) 13683 { 13684 static const xcb_protocol_request_t xcb_req = { 13685 /* count */ 2, 13686 /* ext */ 0, 13687 /* opcode */ XCB_FREE_CURSOR, 13688 /* isvoid */ 1 13689 }; 13690 13691 struct iovec xcb_parts[4]; 13692 xcb_void_cookie_t xcb_ret; 13693 xcb_free_cursor_request_t xcb_out; 13694 13695 xcb_out.pad0 = 0; 13696 xcb_out.cursor = cursor; 13697 13698 xcb_parts[2].iov_base = (char *) &xcb_out; 13699 xcb_parts[2].iov_len = sizeof(xcb_out); 13700 xcb_parts[3].iov_base = 0; 13701 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13702 13703 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13704 return xcb_ret; 13705 } 13706 13707 13708 /***************************************************************************** 13709 ** 13710 ** xcb_void_cookie_t xcb_free_cursor 13711 ** 13712 ** @param xcb_connection_t *c 13713 ** @param xcb_cursor_t cursor 13714 ** @returns xcb_void_cookie_t 13715 ** 13716 *****************************************************************************/ 13717 13718 xcb_void_cookie_t 13719 xcb_free_cursor (xcb_connection_t *c /**< */, 13720 xcb_cursor_t cursor /**< */) 13721 { 13722 static const xcb_protocol_request_t xcb_req = { 13723 /* count */ 2, 13724 /* ext */ 0, 13725 /* opcode */ XCB_FREE_CURSOR, 13726 /* isvoid */ 1 13727 }; 13728 13729 struct iovec xcb_parts[4]; 13730 xcb_void_cookie_t xcb_ret; 13731 xcb_free_cursor_request_t xcb_out; 13732 13733 xcb_out.pad0 = 0; 13734 xcb_out.cursor = cursor; 13735 13736 xcb_parts[2].iov_base = (char *) &xcb_out; 13737 xcb_parts[2].iov_len = sizeof(xcb_out); 13738 xcb_parts[3].iov_base = 0; 13739 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13740 13741 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13742 return xcb_ret; 13743 } 13744 13745 13746 /***************************************************************************** 13747 ** 13748 ** xcb_void_cookie_t xcb_recolor_cursor_checked 13749 ** 13750 ** @param xcb_connection_t *c 13751 ** @param xcb_cursor_t cursor 13752 ** @param uint16_t fore_red 13753 ** @param uint16_t fore_green 13754 ** @param uint16_t fore_blue 13755 ** @param uint16_t back_red 13756 ** @param uint16_t back_green 13757 ** @param uint16_t back_blue 13758 ** @returns xcb_void_cookie_t 13759 ** 13760 *****************************************************************************/ 13761 13762 xcb_void_cookie_t 13763 xcb_recolor_cursor_checked (xcb_connection_t *c /**< */, 13764 xcb_cursor_t cursor /**< */, 13765 uint16_t fore_red /**< */, 13766 uint16_t fore_green /**< */, 13767 uint16_t fore_blue /**< */, 13768 uint16_t back_red /**< */, 13769 uint16_t back_green /**< */, 13770 uint16_t back_blue /**< */) 13771 { 13772 static const xcb_protocol_request_t xcb_req = { 13773 /* count */ 2, 13774 /* ext */ 0, 13775 /* opcode */ XCB_RECOLOR_CURSOR, 13776 /* isvoid */ 1 13777 }; 13778 13779 struct iovec xcb_parts[4]; 13780 xcb_void_cookie_t xcb_ret; 13781 xcb_recolor_cursor_request_t xcb_out; 13782 13783 xcb_out.pad0 = 0; 13784 xcb_out.cursor = cursor; 13785 xcb_out.fore_red = fore_red; 13786 xcb_out.fore_green = fore_green; 13787 xcb_out.fore_blue = fore_blue; 13788 xcb_out.back_red = back_red; 13789 xcb_out.back_green = back_green; 13790 xcb_out.back_blue = back_blue; 13791 13792 xcb_parts[2].iov_base = (char *) &xcb_out; 13793 xcb_parts[2].iov_len = sizeof(xcb_out); 13794 xcb_parts[3].iov_base = 0; 13795 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13796 13797 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13798 return xcb_ret; 13799 } 13800 13801 13802 /***************************************************************************** 13803 ** 13804 ** xcb_void_cookie_t xcb_recolor_cursor 13805 ** 13806 ** @param xcb_connection_t *c 13807 ** @param xcb_cursor_t cursor 13808 ** @param uint16_t fore_red 13809 ** @param uint16_t fore_green 13810 ** @param uint16_t fore_blue 13811 ** @param uint16_t back_red 13812 ** @param uint16_t back_green 13813 ** @param uint16_t back_blue 13814 ** @returns xcb_void_cookie_t 13815 ** 13816 *****************************************************************************/ 13817 13818 xcb_void_cookie_t 13819 xcb_recolor_cursor (xcb_connection_t *c /**< */, 13820 xcb_cursor_t cursor /**< */, 13821 uint16_t fore_red /**< */, 13822 uint16_t fore_green /**< */, 13823 uint16_t fore_blue /**< */, 13824 uint16_t back_red /**< */, 13825 uint16_t back_green /**< */, 13826 uint16_t back_blue /**< */) 13827 { 13828 static const xcb_protocol_request_t xcb_req = { 13829 /* count */ 2, 13830 /* ext */ 0, 13831 /* opcode */ XCB_RECOLOR_CURSOR, 13832 /* isvoid */ 1 13833 }; 13834 13835 struct iovec xcb_parts[4]; 13836 xcb_void_cookie_t xcb_ret; 13837 xcb_recolor_cursor_request_t xcb_out; 13838 13839 xcb_out.pad0 = 0; 13840 xcb_out.cursor = cursor; 13841 xcb_out.fore_red = fore_red; 13842 xcb_out.fore_green = fore_green; 13843 xcb_out.fore_blue = fore_blue; 13844 xcb_out.back_red = back_red; 13845 xcb_out.back_green = back_green; 13846 xcb_out.back_blue = back_blue; 13847 13848 xcb_parts[2].iov_base = (char *) &xcb_out; 13849 xcb_parts[2].iov_len = sizeof(xcb_out); 13850 xcb_parts[3].iov_base = 0; 13851 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13852 13853 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13854 return xcb_ret; 13855 } 13856 13857 13858 /***************************************************************************** 13859 ** 13860 ** xcb_query_best_size_cookie_t xcb_query_best_size 13861 ** 13862 ** @param xcb_connection_t *c 13863 ** @param uint8_t _class 13864 ** @param xcb_drawable_t drawable 13865 ** @param uint16_t width 13866 ** @param uint16_t height 13867 ** @returns xcb_query_best_size_cookie_t 13868 ** 13869 *****************************************************************************/ 13870 13871 xcb_query_best_size_cookie_t 13872 xcb_query_best_size (xcb_connection_t *c /**< */, 13873 uint8_t _class /**< */, 13874 xcb_drawable_t drawable /**< */, 13875 uint16_t width /**< */, 13876 uint16_t height /**< */) 13877 { 13878 static const xcb_protocol_request_t xcb_req = { 13879 /* count */ 2, 13880 /* ext */ 0, 13881 /* opcode */ XCB_QUERY_BEST_SIZE, 13882 /* isvoid */ 0 13883 }; 13884 13885 struct iovec xcb_parts[4]; 13886 xcb_query_best_size_cookie_t xcb_ret; 13887 xcb_query_best_size_request_t xcb_out; 13888 13889 xcb_out._class = _class; 13890 xcb_out.drawable = drawable; 13891 xcb_out.width = width; 13892 xcb_out.height = height; 13893 13894 xcb_parts[2].iov_base = (char *) &xcb_out; 13895 xcb_parts[2].iov_len = sizeof(xcb_out); 13896 xcb_parts[3].iov_base = 0; 13897 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13898 13899 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 13900 return xcb_ret; 13901 } 13902 13903 13904 /***************************************************************************** 13905 ** 13906 ** xcb_query_best_size_cookie_t xcb_query_best_size_unchecked 13907 ** 13908 ** @param xcb_connection_t *c 13909 ** @param uint8_t _class 13910 ** @param xcb_drawable_t drawable 13911 ** @param uint16_t width 13912 ** @param uint16_t height 13913 ** @returns xcb_query_best_size_cookie_t 13914 ** 13915 *****************************************************************************/ 13916 13917 xcb_query_best_size_cookie_t 13918 xcb_query_best_size_unchecked (xcb_connection_t *c /**< */, 13919 uint8_t _class /**< */, 13920 xcb_drawable_t drawable /**< */, 13921 uint16_t width /**< */, 13922 uint16_t height /**< */) 13923 { 13924 static const xcb_protocol_request_t xcb_req = { 13925 /* count */ 2, 13926 /* ext */ 0, 13927 /* opcode */ XCB_QUERY_BEST_SIZE, 13928 /* isvoid */ 0 13929 }; 13930 13931 struct iovec xcb_parts[4]; 13932 xcb_query_best_size_cookie_t xcb_ret; 13933 xcb_query_best_size_request_t xcb_out; 13934 13935 xcb_out._class = _class; 13936 xcb_out.drawable = drawable; 13937 xcb_out.width = width; 13938 xcb_out.height = height; 13939 13940 xcb_parts[2].iov_base = (char *) &xcb_out; 13941 xcb_parts[2].iov_len = sizeof(xcb_out); 13942 xcb_parts[3].iov_base = 0; 13943 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 13944 13945 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 13946 return xcb_ret; 13947 } 13948 13949 13950 /***************************************************************************** 13951 ** 13952 ** xcb_query_best_size_reply_t * xcb_query_best_size_reply 13953 ** 13954 ** @param xcb_connection_t *c 13955 ** @param xcb_query_best_size_cookie_t cookie 13956 ** @param xcb_generic_error_t **e 13957 ** @returns xcb_query_best_size_reply_t * 13958 ** 13959 *****************************************************************************/ 13960 13961 xcb_query_best_size_reply_t * 13962 xcb_query_best_size_reply (xcb_connection_t *c /**< */, 13963 xcb_query_best_size_cookie_t cookie /**< */, 13964 xcb_generic_error_t **e /**< */) 13965 { 13966 return (xcb_query_best_size_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 13967 } 13968 13969 int 13970 xcb_query_extension_sizeof (const void *_buffer /**< */) 13971 { 13972 char *xcb_tmp = (char *)_buffer; 13973 const xcb_query_extension_request_t *_aux = (xcb_query_extension_request_t *)_buffer; 13974 unsigned int xcb_buffer_len = 0; 13975 unsigned int xcb_block_len = 0; 13976 unsigned int xcb_pad = 0; 13977 unsigned int xcb_align_to; 13978 13979 13980 xcb_block_len += sizeof(xcb_query_extension_request_t); 13981 xcb_tmp += xcb_block_len; 13982 /* name */ 13983 xcb_block_len += _aux->name_len * sizeof(char); 13984 xcb_tmp += xcb_block_len; 13985 xcb_align_to = ALIGNOF(char); 13986 /* insert padding */ 13987 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 13988 xcb_buffer_len += xcb_block_len + xcb_pad; 13989 if (0 != xcb_pad) { 13990 xcb_tmp += xcb_pad; 13991 xcb_pad = 0; 13992 } 13993 xcb_block_len = 0; 13994 13995 return xcb_buffer_len; 13996 } 13997 13998 13999 /***************************************************************************** 14000 ** 14001 ** xcb_query_extension_cookie_t xcb_query_extension 14002 ** 14003 ** @param xcb_connection_t *c 14004 ** @param uint16_t name_len 14005 ** @param const char *name 14006 ** @returns xcb_query_extension_cookie_t 14007 ** 14008 *****************************************************************************/ 14009 14010 xcb_query_extension_cookie_t 14011 xcb_query_extension (xcb_connection_t *c /**< */, 14012 uint16_t name_len /**< */, 14013 const char *name /**< */) 14014 { 14015 static const xcb_protocol_request_t xcb_req = { 14016 /* count */ 4, 14017 /* ext */ 0, 14018 /* opcode */ XCB_QUERY_EXTENSION, 14019 /* isvoid */ 0 14020 }; 14021 14022 struct iovec xcb_parts[6]; 14023 xcb_query_extension_cookie_t xcb_ret; 14024 xcb_query_extension_request_t xcb_out; 14025 14026 xcb_out.pad0 = 0; 14027 xcb_out.name_len = name_len; 14028 memset(xcb_out.pad1, 0, 2); 14029 14030 xcb_parts[2].iov_base = (char *) &xcb_out; 14031 xcb_parts[2].iov_len = sizeof(xcb_out); 14032 xcb_parts[3].iov_base = 0; 14033 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14034 /* char name */ 14035 xcb_parts[4].iov_base = (char *) name; 14036 xcb_parts[4].iov_len = name_len * sizeof(char); 14037 xcb_parts[5].iov_base = 0; 14038 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14039 14040 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14041 return xcb_ret; 14042 } 14043 14044 14045 /***************************************************************************** 14046 ** 14047 ** xcb_query_extension_cookie_t xcb_query_extension_unchecked 14048 ** 14049 ** @param xcb_connection_t *c 14050 ** @param uint16_t name_len 14051 ** @param const char *name 14052 ** @returns xcb_query_extension_cookie_t 14053 ** 14054 *****************************************************************************/ 14055 14056 xcb_query_extension_cookie_t 14057 xcb_query_extension_unchecked (xcb_connection_t *c /**< */, 14058 uint16_t name_len /**< */, 14059 const char *name /**< */) 14060 { 14061 static const xcb_protocol_request_t xcb_req = { 14062 /* count */ 4, 14063 /* ext */ 0, 14064 /* opcode */ XCB_QUERY_EXTENSION, 14065 /* isvoid */ 0 14066 }; 14067 14068 struct iovec xcb_parts[6]; 14069 xcb_query_extension_cookie_t xcb_ret; 14070 xcb_query_extension_request_t xcb_out; 14071 14072 xcb_out.pad0 = 0; 14073 xcb_out.name_len = name_len; 14074 memset(xcb_out.pad1, 0, 2); 14075 14076 xcb_parts[2].iov_base = (char *) &xcb_out; 14077 xcb_parts[2].iov_len = sizeof(xcb_out); 14078 xcb_parts[3].iov_base = 0; 14079 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14080 /* char name */ 14081 xcb_parts[4].iov_base = (char *) name; 14082 xcb_parts[4].iov_len = name_len * sizeof(char); 14083 xcb_parts[5].iov_base = 0; 14084 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14085 14086 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14087 return xcb_ret; 14088 } 14089 14090 14091 /***************************************************************************** 14092 ** 14093 ** xcb_query_extension_reply_t * xcb_query_extension_reply 14094 ** 14095 ** @param xcb_connection_t *c 14096 ** @param xcb_query_extension_cookie_t cookie 14097 ** @param xcb_generic_error_t **e 14098 ** @returns xcb_query_extension_reply_t * 14099 ** 14100 *****************************************************************************/ 14101 14102 xcb_query_extension_reply_t * 14103 xcb_query_extension_reply (xcb_connection_t *c /**< */, 14104 xcb_query_extension_cookie_t cookie /**< */, 14105 xcb_generic_error_t **e /**< */) 14106 { 14107 return (xcb_query_extension_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14108 } 14109 14110 int 14111 xcb_list_extensions_sizeof (const void *_buffer /**< */) 14112 { 14113 char *xcb_tmp = (char *)_buffer; 14114 const xcb_list_extensions_reply_t *_aux = (xcb_list_extensions_reply_t *)_buffer; 14115 unsigned int xcb_buffer_len = 0; 14116 unsigned int xcb_block_len = 0; 14117 unsigned int xcb_pad = 0; 14118 unsigned int xcb_align_to; 14119 14120 unsigned int i; 14121 unsigned int xcb_tmp_len; 14122 14123 xcb_block_len += sizeof(xcb_list_extensions_reply_t); 14124 xcb_tmp += xcb_block_len; 14125 /* names */ 14126 for(i=0; i<_aux->names_len; i++) { 14127 xcb_tmp_len = xcb_str_sizeof(xcb_tmp); 14128 xcb_block_len += xcb_tmp_len; 14129 xcb_tmp += xcb_tmp_len; 14130 } 14131 xcb_align_to = ALIGNOF(xcb_str_t); 14132 /* insert padding */ 14133 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14134 xcb_buffer_len += xcb_block_len + xcb_pad; 14135 if (0 != xcb_pad) { 14136 xcb_tmp += xcb_pad; 14137 xcb_pad = 0; 14138 } 14139 xcb_block_len = 0; 14140 14141 return xcb_buffer_len; 14142 } 14143 14144 14145 /***************************************************************************** 14146 ** 14147 ** xcb_list_extensions_cookie_t xcb_list_extensions 14148 ** 14149 ** @param xcb_connection_t *c 14150 ** @returns xcb_list_extensions_cookie_t 14151 ** 14152 *****************************************************************************/ 14153 14154 xcb_list_extensions_cookie_t 14155 xcb_list_extensions (xcb_connection_t *c /**< */) 14156 { 14157 static const xcb_protocol_request_t xcb_req = { 14158 /* count */ 2, 14159 /* ext */ 0, 14160 /* opcode */ XCB_LIST_EXTENSIONS, 14161 /* isvoid */ 0 14162 }; 14163 14164 struct iovec xcb_parts[4]; 14165 xcb_list_extensions_cookie_t xcb_ret; 14166 xcb_list_extensions_request_t xcb_out; 14167 14168 xcb_out.pad0 = 0; 14169 14170 xcb_parts[2].iov_base = (char *) &xcb_out; 14171 xcb_parts[2].iov_len = sizeof(xcb_out); 14172 xcb_parts[3].iov_base = 0; 14173 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14174 14175 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14176 return xcb_ret; 14177 } 14178 14179 14180 /***************************************************************************** 14181 ** 14182 ** xcb_list_extensions_cookie_t xcb_list_extensions_unchecked 14183 ** 14184 ** @param xcb_connection_t *c 14185 ** @returns xcb_list_extensions_cookie_t 14186 ** 14187 *****************************************************************************/ 14188 14189 xcb_list_extensions_cookie_t 14190 xcb_list_extensions_unchecked (xcb_connection_t *c /**< */) 14191 { 14192 static const xcb_protocol_request_t xcb_req = { 14193 /* count */ 2, 14194 /* ext */ 0, 14195 /* opcode */ XCB_LIST_EXTENSIONS, 14196 /* isvoid */ 0 14197 }; 14198 14199 struct iovec xcb_parts[4]; 14200 xcb_list_extensions_cookie_t xcb_ret; 14201 xcb_list_extensions_request_t xcb_out; 14202 14203 xcb_out.pad0 = 0; 14204 14205 xcb_parts[2].iov_base = (char *) &xcb_out; 14206 xcb_parts[2].iov_len = sizeof(xcb_out); 14207 xcb_parts[3].iov_base = 0; 14208 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14209 14210 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14211 return xcb_ret; 14212 } 14213 14214 14215 /***************************************************************************** 14216 ** 14217 ** int xcb_list_extensions_names_length 14218 ** 14219 ** @param const xcb_list_extensions_reply_t *R 14220 ** @returns int 14221 ** 14222 *****************************************************************************/ 14223 14224 int 14225 xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R /**< */) 14226 { 14227 return R->names_len; 14228 } 14229 14230 14231 /***************************************************************************** 14232 ** 14233 ** xcb_str_iterator_t xcb_list_extensions_names_iterator 14234 ** 14235 ** @param const xcb_list_extensions_reply_t *R 14236 ** @returns xcb_str_iterator_t 14237 ** 14238 *****************************************************************************/ 14239 14240 xcb_str_iterator_t 14241 xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R /**< */) 14242 { 14243 xcb_str_iterator_t i; 14244 i.data = (xcb_str_t *) (R + 1); 14245 i.rem = R->names_len; 14246 i.index = (char *) i.data - (char *) R; 14247 return i; 14248 } 14249 14250 14251 /***************************************************************************** 14252 ** 14253 ** xcb_list_extensions_reply_t * xcb_list_extensions_reply 14254 ** 14255 ** @param xcb_connection_t *c 14256 ** @param xcb_list_extensions_cookie_t cookie 14257 ** @param xcb_generic_error_t **e 14258 ** @returns xcb_list_extensions_reply_t * 14259 ** 14260 *****************************************************************************/ 14261 14262 xcb_list_extensions_reply_t * 14263 xcb_list_extensions_reply (xcb_connection_t *c /**< */, 14264 xcb_list_extensions_cookie_t cookie /**< */, 14265 xcb_generic_error_t **e /**< */) 14266 { 14267 return (xcb_list_extensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14268 } 14269 14270 int 14271 xcb_change_keyboard_mapping_sizeof (const void *_buffer /**< */) 14272 { 14273 char *xcb_tmp = (char *)_buffer; 14274 const xcb_change_keyboard_mapping_request_t *_aux = (xcb_change_keyboard_mapping_request_t *)_buffer; 14275 unsigned int xcb_buffer_len = 0; 14276 unsigned int xcb_block_len = 0; 14277 unsigned int xcb_pad = 0; 14278 unsigned int xcb_align_to; 14279 14280 14281 xcb_block_len += sizeof(xcb_change_keyboard_mapping_request_t); 14282 xcb_tmp += xcb_block_len; 14283 /* keysyms */ 14284 xcb_block_len += (_aux->keycode_count * _aux->keysyms_per_keycode) * sizeof(xcb_keysym_t); 14285 xcb_tmp += xcb_block_len; 14286 xcb_align_to = ALIGNOF(xcb_keysym_t); 14287 /* insert padding */ 14288 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14289 xcb_buffer_len += xcb_block_len + xcb_pad; 14290 if (0 != xcb_pad) { 14291 xcb_tmp += xcb_pad; 14292 xcb_pad = 0; 14293 } 14294 xcb_block_len = 0; 14295 14296 return xcb_buffer_len; 14297 } 14298 14299 14300 /***************************************************************************** 14301 ** 14302 ** xcb_void_cookie_t xcb_change_keyboard_mapping_checked 14303 ** 14304 ** @param xcb_connection_t *c 14305 ** @param uint8_t keycode_count 14306 ** @param xcb_keycode_t first_keycode 14307 ** @param uint8_t keysyms_per_keycode 14308 ** @param const xcb_keysym_t *keysyms 14309 ** @returns xcb_void_cookie_t 14310 ** 14311 *****************************************************************************/ 14312 14313 xcb_void_cookie_t 14314 xcb_change_keyboard_mapping_checked (xcb_connection_t *c /**< */, 14315 uint8_t keycode_count /**< */, 14316 xcb_keycode_t first_keycode /**< */, 14317 uint8_t keysyms_per_keycode /**< */, 14318 const xcb_keysym_t *keysyms /**< */) 14319 { 14320 static const xcb_protocol_request_t xcb_req = { 14321 /* count */ 4, 14322 /* ext */ 0, 14323 /* opcode */ XCB_CHANGE_KEYBOARD_MAPPING, 14324 /* isvoid */ 1 14325 }; 14326 14327 struct iovec xcb_parts[6]; 14328 xcb_void_cookie_t xcb_ret; 14329 xcb_change_keyboard_mapping_request_t xcb_out; 14330 14331 xcb_out.keycode_count = keycode_count; 14332 xcb_out.first_keycode = first_keycode; 14333 xcb_out.keysyms_per_keycode = keysyms_per_keycode; 14334 memset(xcb_out.pad0, 0, 2); 14335 14336 xcb_parts[2].iov_base = (char *) &xcb_out; 14337 xcb_parts[2].iov_len = sizeof(xcb_out); 14338 xcb_parts[3].iov_base = 0; 14339 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14340 /* xcb_keysym_t keysyms */ 14341 xcb_parts[4].iov_base = (char *) keysyms; 14342 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); 14343 xcb_parts[5].iov_base = 0; 14344 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14345 14346 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14347 return xcb_ret; 14348 } 14349 14350 14351 /***************************************************************************** 14352 ** 14353 ** xcb_void_cookie_t xcb_change_keyboard_mapping 14354 ** 14355 ** @param xcb_connection_t *c 14356 ** @param uint8_t keycode_count 14357 ** @param xcb_keycode_t first_keycode 14358 ** @param uint8_t keysyms_per_keycode 14359 ** @param const xcb_keysym_t *keysyms 14360 ** @returns xcb_void_cookie_t 14361 ** 14362 *****************************************************************************/ 14363 14364 xcb_void_cookie_t 14365 xcb_change_keyboard_mapping (xcb_connection_t *c /**< */, 14366 uint8_t keycode_count /**< */, 14367 xcb_keycode_t first_keycode /**< */, 14368 uint8_t keysyms_per_keycode /**< */, 14369 const xcb_keysym_t *keysyms /**< */) 14370 { 14371 static const xcb_protocol_request_t xcb_req = { 14372 /* count */ 4, 14373 /* ext */ 0, 14374 /* opcode */ XCB_CHANGE_KEYBOARD_MAPPING, 14375 /* isvoid */ 1 14376 }; 14377 14378 struct iovec xcb_parts[6]; 14379 xcb_void_cookie_t xcb_ret; 14380 xcb_change_keyboard_mapping_request_t xcb_out; 14381 14382 xcb_out.keycode_count = keycode_count; 14383 xcb_out.first_keycode = first_keycode; 14384 xcb_out.keysyms_per_keycode = keysyms_per_keycode; 14385 memset(xcb_out.pad0, 0, 2); 14386 14387 xcb_parts[2].iov_base = (char *) &xcb_out; 14388 xcb_parts[2].iov_len = sizeof(xcb_out); 14389 xcb_parts[3].iov_base = 0; 14390 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14391 /* xcb_keysym_t keysyms */ 14392 xcb_parts[4].iov_base = (char *) keysyms; 14393 xcb_parts[4].iov_len = (keycode_count * keysyms_per_keycode) * sizeof(xcb_keysym_t); 14394 xcb_parts[5].iov_base = 0; 14395 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14396 14397 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14398 return xcb_ret; 14399 } 14400 14401 int 14402 xcb_get_keyboard_mapping_sizeof (const void *_buffer /**< */) 14403 { 14404 char *xcb_tmp = (char *)_buffer; 14405 const xcb_get_keyboard_mapping_reply_t *_aux = (xcb_get_keyboard_mapping_reply_t *)_buffer; 14406 unsigned int xcb_buffer_len = 0; 14407 unsigned int xcb_block_len = 0; 14408 unsigned int xcb_pad = 0; 14409 unsigned int xcb_align_to; 14410 14411 14412 xcb_block_len += sizeof(xcb_get_keyboard_mapping_reply_t); 14413 xcb_tmp += xcb_block_len; 14414 /* keysyms */ 14415 xcb_block_len += _aux->length * sizeof(xcb_keysym_t); 14416 xcb_tmp += xcb_block_len; 14417 xcb_align_to = ALIGNOF(xcb_keysym_t); 14418 /* insert padding */ 14419 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14420 xcb_buffer_len += xcb_block_len + xcb_pad; 14421 if (0 != xcb_pad) { 14422 xcb_tmp += xcb_pad; 14423 xcb_pad = 0; 14424 } 14425 xcb_block_len = 0; 14426 14427 return xcb_buffer_len; 14428 } 14429 14430 14431 /***************************************************************************** 14432 ** 14433 ** xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping 14434 ** 14435 ** @param xcb_connection_t *c 14436 ** @param xcb_keycode_t first_keycode 14437 ** @param uint8_t count 14438 ** @returns xcb_get_keyboard_mapping_cookie_t 14439 ** 14440 *****************************************************************************/ 14441 14442 xcb_get_keyboard_mapping_cookie_t 14443 xcb_get_keyboard_mapping (xcb_connection_t *c /**< */, 14444 xcb_keycode_t first_keycode /**< */, 14445 uint8_t count /**< */) 14446 { 14447 static const xcb_protocol_request_t xcb_req = { 14448 /* count */ 2, 14449 /* ext */ 0, 14450 /* opcode */ XCB_GET_KEYBOARD_MAPPING, 14451 /* isvoid */ 0 14452 }; 14453 14454 struct iovec xcb_parts[4]; 14455 xcb_get_keyboard_mapping_cookie_t xcb_ret; 14456 xcb_get_keyboard_mapping_request_t xcb_out; 14457 14458 xcb_out.pad0 = 0; 14459 xcb_out.first_keycode = first_keycode; 14460 xcb_out.count = count; 14461 14462 xcb_parts[2].iov_base = (char *) &xcb_out; 14463 xcb_parts[2].iov_len = sizeof(xcb_out); 14464 xcb_parts[3].iov_base = 0; 14465 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14466 14467 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14468 return xcb_ret; 14469 } 14470 14471 14472 /***************************************************************************** 14473 ** 14474 ** xcb_get_keyboard_mapping_cookie_t xcb_get_keyboard_mapping_unchecked 14475 ** 14476 ** @param xcb_connection_t *c 14477 ** @param xcb_keycode_t first_keycode 14478 ** @param uint8_t count 14479 ** @returns xcb_get_keyboard_mapping_cookie_t 14480 ** 14481 *****************************************************************************/ 14482 14483 xcb_get_keyboard_mapping_cookie_t 14484 xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c /**< */, 14485 xcb_keycode_t first_keycode /**< */, 14486 uint8_t count /**< */) 14487 { 14488 static const xcb_protocol_request_t xcb_req = { 14489 /* count */ 2, 14490 /* ext */ 0, 14491 /* opcode */ XCB_GET_KEYBOARD_MAPPING, 14492 /* isvoid */ 0 14493 }; 14494 14495 struct iovec xcb_parts[4]; 14496 xcb_get_keyboard_mapping_cookie_t xcb_ret; 14497 xcb_get_keyboard_mapping_request_t xcb_out; 14498 14499 xcb_out.pad0 = 0; 14500 xcb_out.first_keycode = first_keycode; 14501 xcb_out.count = count; 14502 14503 xcb_parts[2].iov_base = (char *) &xcb_out; 14504 xcb_parts[2].iov_len = sizeof(xcb_out); 14505 xcb_parts[3].iov_base = 0; 14506 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14507 14508 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14509 return xcb_ret; 14510 } 14511 14512 14513 /***************************************************************************** 14514 ** 14515 ** xcb_keysym_t * xcb_get_keyboard_mapping_keysyms 14516 ** 14517 ** @param const xcb_get_keyboard_mapping_reply_t *R 14518 ** @returns xcb_keysym_t * 14519 ** 14520 *****************************************************************************/ 14521 14522 xcb_keysym_t * 14523 xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R /**< */) 14524 { 14525 return (xcb_keysym_t *) (R + 1); 14526 } 14527 14528 14529 /***************************************************************************** 14530 ** 14531 ** int xcb_get_keyboard_mapping_keysyms_length 14532 ** 14533 ** @param const xcb_get_keyboard_mapping_reply_t *R 14534 ** @returns int 14535 ** 14536 *****************************************************************************/ 14537 14538 int 14539 xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R /**< */) 14540 { 14541 return R->length; 14542 } 14543 14544 14545 /***************************************************************************** 14546 ** 14547 ** xcb_generic_iterator_t xcb_get_keyboard_mapping_keysyms_end 14548 ** 14549 ** @param const xcb_get_keyboard_mapping_reply_t *R 14550 ** @returns xcb_generic_iterator_t 14551 ** 14552 *****************************************************************************/ 14553 14554 xcb_generic_iterator_t 14555 xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R /**< */) 14556 { 14557 xcb_generic_iterator_t i; 14558 i.data = ((xcb_keysym_t *) (R + 1)) + (R->length); 14559 i.rem = 0; 14560 i.index = (char *) i.data - (char *) R; 14561 return i; 14562 } 14563 14564 14565 /***************************************************************************** 14566 ** 14567 ** xcb_get_keyboard_mapping_reply_t * xcb_get_keyboard_mapping_reply 14568 ** 14569 ** @param xcb_connection_t *c 14570 ** @param xcb_get_keyboard_mapping_cookie_t cookie 14571 ** @param xcb_generic_error_t **e 14572 ** @returns xcb_get_keyboard_mapping_reply_t * 14573 ** 14574 *****************************************************************************/ 14575 14576 xcb_get_keyboard_mapping_reply_t * 14577 xcb_get_keyboard_mapping_reply (xcb_connection_t *c /**< */, 14578 xcb_get_keyboard_mapping_cookie_t cookie /**< */, 14579 xcb_generic_error_t **e /**< */) 14580 { 14581 return (xcb_get_keyboard_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14582 } 14583 14584 int 14585 xcb_change_keyboard_control_sizeof (const void *_buffer /**< */) 14586 { 14587 char *xcb_tmp = (char *)_buffer; 14588 const xcb_change_keyboard_control_request_t *_aux = (xcb_change_keyboard_control_request_t *)_buffer; 14589 unsigned int xcb_buffer_len = 0; 14590 unsigned int xcb_block_len = 0; 14591 unsigned int xcb_pad = 0; 14592 unsigned int xcb_align_to; 14593 14594 14595 xcb_block_len += sizeof(xcb_change_keyboard_control_request_t); 14596 xcb_tmp += xcb_block_len; 14597 /* value_list */ 14598 xcb_block_len += xcb_popcount(_aux->value_mask) * sizeof(uint32_t); 14599 xcb_tmp += xcb_block_len; 14600 xcb_align_to = ALIGNOF(uint32_t); 14601 /* insert padding */ 14602 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 14603 xcb_buffer_len += xcb_block_len + xcb_pad; 14604 if (0 != xcb_pad) { 14605 xcb_tmp += xcb_pad; 14606 xcb_pad = 0; 14607 } 14608 xcb_block_len = 0; 14609 14610 return xcb_buffer_len; 14611 } 14612 14613 14614 /***************************************************************************** 14615 ** 14616 ** xcb_void_cookie_t xcb_change_keyboard_control_checked 14617 ** 14618 ** @param xcb_connection_t *c 14619 ** @param uint32_t value_mask 14620 ** @param const uint32_t *value_list 14621 ** @returns xcb_void_cookie_t 14622 ** 14623 *****************************************************************************/ 14624 14625 xcb_void_cookie_t 14626 xcb_change_keyboard_control_checked (xcb_connection_t *c /**< */, 14627 uint32_t value_mask /**< */, 14628 const uint32_t *value_list /**< */) 14629 { 14630 static const xcb_protocol_request_t xcb_req = { 14631 /* count */ 4, 14632 /* ext */ 0, 14633 /* opcode */ XCB_CHANGE_KEYBOARD_CONTROL, 14634 /* isvoid */ 1 14635 }; 14636 14637 struct iovec xcb_parts[6]; 14638 xcb_void_cookie_t xcb_ret; 14639 xcb_change_keyboard_control_request_t xcb_out; 14640 14641 xcb_out.pad0 = 0; 14642 xcb_out.value_mask = value_mask; 14643 14644 xcb_parts[2].iov_base = (char *) &xcb_out; 14645 xcb_parts[2].iov_len = sizeof(xcb_out); 14646 xcb_parts[3].iov_base = 0; 14647 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14648 /* uint32_t value_list */ 14649 xcb_parts[4].iov_base = (char *) value_list; 14650 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 14651 xcb_parts[5].iov_base = 0; 14652 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14653 14654 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14655 return xcb_ret; 14656 } 14657 14658 14659 /***************************************************************************** 14660 ** 14661 ** xcb_void_cookie_t xcb_change_keyboard_control 14662 ** 14663 ** @param xcb_connection_t *c 14664 ** @param uint32_t value_mask 14665 ** @param const uint32_t *value_list 14666 ** @returns xcb_void_cookie_t 14667 ** 14668 *****************************************************************************/ 14669 14670 xcb_void_cookie_t 14671 xcb_change_keyboard_control (xcb_connection_t *c /**< */, 14672 uint32_t value_mask /**< */, 14673 const uint32_t *value_list /**< */) 14674 { 14675 static const xcb_protocol_request_t xcb_req = { 14676 /* count */ 4, 14677 /* ext */ 0, 14678 /* opcode */ XCB_CHANGE_KEYBOARD_CONTROL, 14679 /* isvoid */ 1 14680 }; 14681 14682 struct iovec xcb_parts[6]; 14683 xcb_void_cookie_t xcb_ret; 14684 xcb_change_keyboard_control_request_t xcb_out; 14685 14686 xcb_out.pad0 = 0; 14687 xcb_out.value_mask = value_mask; 14688 14689 xcb_parts[2].iov_base = (char *) &xcb_out; 14690 xcb_parts[2].iov_len = sizeof(xcb_out); 14691 xcb_parts[3].iov_base = 0; 14692 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14693 /* uint32_t value_list */ 14694 xcb_parts[4].iov_base = (char *) value_list; 14695 xcb_parts[4].iov_len = xcb_popcount(value_mask) * sizeof(uint32_t); 14696 xcb_parts[5].iov_base = 0; 14697 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 14698 14699 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14700 return xcb_ret; 14701 } 14702 14703 14704 /***************************************************************************** 14705 ** 14706 ** xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control 14707 ** 14708 ** @param xcb_connection_t *c 14709 ** @returns xcb_get_keyboard_control_cookie_t 14710 ** 14711 *****************************************************************************/ 14712 14713 xcb_get_keyboard_control_cookie_t 14714 xcb_get_keyboard_control (xcb_connection_t *c /**< */) 14715 { 14716 static const xcb_protocol_request_t xcb_req = { 14717 /* count */ 2, 14718 /* ext */ 0, 14719 /* opcode */ XCB_GET_KEYBOARD_CONTROL, 14720 /* isvoid */ 0 14721 }; 14722 14723 struct iovec xcb_parts[4]; 14724 xcb_get_keyboard_control_cookie_t xcb_ret; 14725 xcb_get_keyboard_control_request_t xcb_out; 14726 14727 xcb_out.pad0 = 0; 14728 14729 xcb_parts[2].iov_base = (char *) &xcb_out; 14730 xcb_parts[2].iov_len = sizeof(xcb_out); 14731 xcb_parts[3].iov_base = 0; 14732 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14733 14734 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14735 return xcb_ret; 14736 } 14737 14738 14739 /***************************************************************************** 14740 ** 14741 ** xcb_get_keyboard_control_cookie_t xcb_get_keyboard_control_unchecked 14742 ** 14743 ** @param xcb_connection_t *c 14744 ** @returns xcb_get_keyboard_control_cookie_t 14745 ** 14746 *****************************************************************************/ 14747 14748 xcb_get_keyboard_control_cookie_t 14749 xcb_get_keyboard_control_unchecked (xcb_connection_t *c /**< */) 14750 { 14751 static const xcb_protocol_request_t xcb_req = { 14752 /* count */ 2, 14753 /* ext */ 0, 14754 /* opcode */ XCB_GET_KEYBOARD_CONTROL, 14755 /* isvoid */ 0 14756 }; 14757 14758 struct iovec xcb_parts[4]; 14759 xcb_get_keyboard_control_cookie_t xcb_ret; 14760 xcb_get_keyboard_control_request_t xcb_out; 14761 14762 xcb_out.pad0 = 0; 14763 14764 xcb_parts[2].iov_base = (char *) &xcb_out; 14765 xcb_parts[2].iov_len = sizeof(xcb_out); 14766 xcb_parts[3].iov_base = 0; 14767 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14768 14769 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14770 return xcb_ret; 14771 } 14772 14773 14774 /***************************************************************************** 14775 ** 14776 ** xcb_get_keyboard_control_reply_t * xcb_get_keyboard_control_reply 14777 ** 14778 ** @param xcb_connection_t *c 14779 ** @param xcb_get_keyboard_control_cookie_t cookie 14780 ** @param xcb_generic_error_t **e 14781 ** @returns xcb_get_keyboard_control_reply_t * 14782 ** 14783 *****************************************************************************/ 14784 14785 xcb_get_keyboard_control_reply_t * 14786 xcb_get_keyboard_control_reply (xcb_connection_t *c /**< */, 14787 xcb_get_keyboard_control_cookie_t cookie /**< */, 14788 xcb_generic_error_t **e /**< */) 14789 { 14790 return (xcb_get_keyboard_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 14791 } 14792 14793 14794 /***************************************************************************** 14795 ** 14796 ** xcb_void_cookie_t xcb_bell_checked 14797 ** 14798 ** @param xcb_connection_t *c 14799 ** @param int8_t percent 14800 ** @returns xcb_void_cookie_t 14801 ** 14802 *****************************************************************************/ 14803 14804 xcb_void_cookie_t 14805 xcb_bell_checked (xcb_connection_t *c /**< */, 14806 int8_t percent /**< */) 14807 { 14808 static const xcb_protocol_request_t xcb_req = { 14809 /* count */ 2, 14810 /* ext */ 0, 14811 /* opcode */ XCB_BELL, 14812 /* isvoid */ 1 14813 }; 14814 14815 struct iovec xcb_parts[4]; 14816 xcb_void_cookie_t xcb_ret; 14817 xcb_bell_request_t xcb_out; 14818 14819 xcb_out.percent = percent; 14820 14821 xcb_parts[2].iov_base = (char *) &xcb_out; 14822 xcb_parts[2].iov_len = sizeof(xcb_out); 14823 xcb_parts[3].iov_base = 0; 14824 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14825 14826 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14827 return xcb_ret; 14828 } 14829 14830 14831 /***************************************************************************** 14832 ** 14833 ** xcb_void_cookie_t xcb_bell 14834 ** 14835 ** @param xcb_connection_t *c 14836 ** @param int8_t percent 14837 ** @returns xcb_void_cookie_t 14838 ** 14839 *****************************************************************************/ 14840 14841 xcb_void_cookie_t 14842 xcb_bell (xcb_connection_t *c /**< */, 14843 int8_t percent /**< */) 14844 { 14845 static const xcb_protocol_request_t xcb_req = { 14846 /* count */ 2, 14847 /* ext */ 0, 14848 /* opcode */ XCB_BELL, 14849 /* isvoid */ 1 14850 }; 14851 14852 struct iovec xcb_parts[4]; 14853 xcb_void_cookie_t xcb_ret; 14854 xcb_bell_request_t xcb_out; 14855 14856 xcb_out.percent = percent; 14857 14858 xcb_parts[2].iov_base = (char *) &xcb_out; 14859 xcb_parts[2].iov_len = sizeof(xcb_out); 14860 xcb_parts[3].iov_base = 0; 14861 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14862 14863 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14864 return xcb_ret; 14865 } 14866 14867 14868 /***************************************************************************** 14869 ** 14870 ** xcb_void_cookie_t xcb_change_pointer_control_checked 14871 ** 14872 ** @param xcb_connection_t *c 14873 ** @param int16_t acceleration_numerator 14874 ** @param int16_t acceleration_denominator 14875 ** @param int16_t threshold 14876 ** @param uint8_t do_acceleration 14877 ** @param uint8_t do_threshold 14878 ** @returns xcb_void_cookie_t 14879 ** 14880 *****************************************************************************/ 14881 14882 xcb_void_cookie_t 14883 xcb_change_pointer_control_checked (xcb_connection_t *c /**< */, 14884 int16_t acceleration_numerator /**< */, 14885 int16_t acceleration_denominator /**< */, 14886 int16_t threshold /**< */, 14887 uint8_t do_acceleration /**< */, 14888 uint8_t do_threshold /**< */) 14889 { 14890 static const xcb_protocol_request_t xcb_req = { 14891 /* count */ 2, 14892 /* ext */ 0, 14893 /* opcode */ XCB_CHANGE_POINTER_CONTROL, 14894 /* isvoid */ 1 14895 }; 14896 14897 struct iovec xcb_parts[4]; 14898 xcb_void_cookie_t xcb_ret; 14899 xcb_change_pointer_control_request_t xcb_out; 14900 14901 xcb_out.pad0 = 0; 14902 xcb_out.acceleration_numerator = acceleration_numerator; 14903 xcb_out.acceleration_denominator = acceleration_denominator; 14904 xcb_out.threshold = threshold; 14905 xcb_out.do_acceleration = do_acceleration; 14906 xcb_out.do_threshold = do_threshold; 14907 14908 xcb_parts[2].iov_base = (char *) &xcb_out; 14909 xcb_parts[2].iov_len = sizeof(xcb_out); 14910 xcb_parts[3].iov_base = 0; 14911 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14912 14913 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14914 return xcb_ret; 14915 } 14916 14917 14918 /***************************************************************************** 14919 ** 14920 ** xcb_void_cookie_t xcb_change_pointer_control 14921 ** 14922 ** @param xcb_connection_t *c 14923 ** @param int16_t acceleration_numerator 14924 ** @param int16_t acceleration_denominator 14925 ** @param int16_t threshold 14926 ** @param uint8_t do_acceleration 14927 ** @param uint8_t do_threshold 14928 ** @returns xcb_void_cookie_t 14929 ** 14930 *****************************************************************************/ 14931 14932 xcb_void_cookie_t 14933 xcb_change_pointer_control (xcb_connection_t *c /**< */, 14934 int16_t acceleration_numerator /**< */, 14935 int16_t acceleration_denominator /**< */, 14936 int16_t threshold /**< */, 14937 uint8_t do_acceleration /**< */, 14938 uint8_t do_threshold /**< */) 14939 { 14940 static const xcb_protocol_request_t xcb_req = { 14941 /* count */ 2, 14942 /* ext */ 0, 14943 /* opcode */ XCB_CHANGE_POINTER_CONTROL, 14944 /* isvoid */ 1 14945 }; 14946 14947 struct iovec xcb_parts[4]; 14948 xcb_void_cookie_t xcb_ret; 14949 xcb_change_pointer_control_request_t xcb_out; 14950 14951 xcb_out.pad0 = 0; 14952 xcb_out.acceleration_numerator = acceleration_numerator; 14953 xcb_out.acceleration_denominator = acceleration_denominator; 14954 xcb_out.threshold = threshold; 14955 xcb_out.do_acceleration = do_acceleration; 14956 xcb_out.do_threshold = do_threshold; 14957 14958 xcb_parts[2].iov_base = (char *) &xcb_out; 14959 xcb_parts[2].iov_len = sizeof(xcb_out); 14960 xcb_parts[3].iov_base = 0; 14961 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14962 14963 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 14964 return xcb_ret; 14965 } 14966 14967 14968 /***************************************************************************** 14969 ** 14970 ** xcb_get_pointer_control_cookie_t xcb_get_pointer_control 14971 ** 14972 ** @param xcb_connection_t *c 14973 ** @returns xcb_get_pointer_control_cookie_t 14974 ** 14975 *****************************************************************************/ 14976 14977 xcb_get_pointer_control_cookie_t 14978 xcb_get_pointer_control (xcb_connection_t *c /**< */) 14979 { 14980 static const xcb_protocol_request_t xcb_req = { 14981 /* count */ 2, 14982 /* ext */ 0, 14983 /* opcode */ XCB_GET_POINTER_CONTROL, 14984 /* isvoid */ 0 14985 }; 14986 14987 struct iovec xcb_parts[4]; 14988 xcb_get_pointer_control_cookie_t xcb_ret; 14989 xcb_get_pointer_control_request_t xcb_out; 14990 14991 xcb_out.pad0 = 0; 14992 14993 xcb_parts[2].iov_base = (char *) &xcb_out; 14994 xcb_parts[2].iov_len = sizeof(xcb_out); 14995 xcb_parts[3].iov_base = 0; 14996 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 14997 14998 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 14999 return xcb_ret; 15000 } 15001 15002 15003 /***************************************************************************** 15004 ** 15005 ** xcb_get_pointer_control_cookie_t xcb_get_pointer_control_unchecked 15006 ** 15007 ** @param xcb_connection_t *c 15008 ** @returns xcb_get_pointer_control_cookie_t 15009 ** 15010 *****************************************************************************/ 15011 15012 xcb_get_pointer_control_cookie_t 15013 xcb_get_pointer_control_unchecked (xcb_connection_t *c /**< */) 15014 { 15015 static const xcb_protocol_request_t xcb_req = { 15016 /* count */ 2, 15017 /* ext */ 0, 15018 /* opcode */ XCB_GET_POINTER_CONTROL, 15019 /* isvoid */ 0 15020 }; 15021 15022 struct iovec xcb_parts[4]; 15023 xcb_get_pointer_control_cookie_t xcb_ret; 15024 xcb_get_pointer_control_request_t xcb_out; 15025 15026 xcb_out.pad0 = 0; 15027 15028 xcb_parts[2].iov_base = (char *) &xcb_out; 15029 xcb_parts[2].iov_len = sizeof(xcb_out); 15030 xcb_parts[3].iov_base = 0; 15031 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15032 15033 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15034 return xcb_ret; 15035 } 15036 15037 15038 /***************************************************************************** 15039 ** 15040 ** xcb_get_pointer_control_reply_t * xcb_get_pointer_control_reply 15041 ** 15042 ** @param xcb_connection_t *c 15043 ** @param xcb_get_pointer_control_cookie_t cookie 15044 ** @param xcb_generic_error_t **e 15045 ** @returns xcb_get_pointer_control_reply_t * 15046 ** 15047 *****************************************************************************/ 15048 15049 xcb_get_pointer_control_reply_t * 15050 xcb_get_pointer_control_reply (xcb_connection_t *c /**< */, 15051 xcb_get_pointer_control_cookie_t cookie /**< */, 15052 xcb_generic_error_t **e /**< */) 15053 { 15054 return (xcb_get_pointer_control_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15055 } 15056 15057 15058 /***************************************************************************** 15059 ** 15060 ** xcb_void_cookie_t xcb_set_screen_saver_checked 15061 ** 15062 ** @param xcb_connection_t *c 15063 ** @param int16_t timeout 15064 ** @param int16_t interval 15065 ** @param uint8_t prefer_blanking 15066 ** @param uint8_t allow_exposures 15067 ** @returns xcb_void_cookie_t 15068 ** 15069 *****************************************************************************/ 15070 15071 xcb_void_cookie_t 15072 xcb_set_screen_saver_checked (xcb_connection_t *c /**< */, 15073 int16_t timeout /**< */, 15074 int16_t interval /**< */, 15075 uint8_t prefer_blanking /**< */, 15076 uint8_t allow_exposures /**< */) 15077 { 15078 static const xcb_protocol_request_t xcb_req = { 15079 /* count */ 2, 15080 /* ext */ 0, 15081 /* opcode */ XCB_SET_SCREEN_SAVER, 15082 /* isvoid */ 1 15083 }; 15084 15085 struct iovec xcb_parts[4]; 15086 xcb_void_cookie_t xcb_ret; 15087 xcb_set_screen_saver_request_t xcb_out; 15088 15089 xcb_out.pad0 = 0; 15090 xcb_out.timeout = timeout; 15091 xcb_out.interval = interval; 15092 xcb_out.prefer_blanking = prefer_blanking; 15093 xcb_out.allow_exposures = allow_exposures; 15094 15095 xcb_parts[2].iov_base = (char *) &xcb_out; 15096 xcb_parts[2].iov_len = sizeof(xcb_out); 15097 xcb_parts[3].iov_base = 0; 15098 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15099 15100 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15101 return xcb_ret; 15102 } 15103 15104 15105 /***************************************************************************** 15106 ** 15107 ** xcb_void_cookie_t xcb_set_screen_saver 15108 ** 15109 ** @param xcb_connection_t *c 15110 ** @param int16_t timeout 15111 ** @param int16_t interval 15112 ** @param uint8_t prefer_blanking 15113 ** @param uint8_t allow_exposures 15114 ** @returns xcb_void_cookie_t 15115 ** 15116 *****************************************************************************/ 15117 15118 xcb_void_cookie_t 15119 xcb_set_screen_saver (xcb_connection_t *c /**< */, 15120 int16_t timeout /**< */, 15121 int16_t interval /**< */, 15122 uint8_t prefer_blanking /**< */, 15123 uint8_t allow_exposures /**< */) 15124 { 15125 static const xcb_protocol_request_t xcb_req = { 15126 /* count */ 2, 15127 /* ext */ 0, 15128 /* opcode */ XCB_SET_SCREEN_SAVER, 15129 /* isvoid */ 1 15130 }; 15131 15132 struct iovec xcb_parts[4]; 15133 xcb_void_cookie_t xcb_ret; 15134 xcb_set_screen_saver_request_t xcb_out; 15135 15136 xcb_out.pad0 = 0; 15137 xcb_out.timeout = timeout; 15138 xcb_out.interval = interval; 15139 xcb_out.prefer_blanking = prefer_blanking; 15140 xcb_out.allow_exposures = allow_exposures; 15141 15142 xcb_parts[2].iov_base = (char *) &xcb_out; 15143 xcb_parts[2].iov_len = sizeof(xcb_out); 15144 xcb_parts[3].iov_base = 0; 15145 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15146 15147 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15148 return xcb_ret; 15149 } 15150 15151 15152 /***************************************************************************** 15153 ** 15154 ** xcb_get_screen_saver_cookie_t xcb_get_screen_saver 15155 ** 15156 ** @param xcb_connection_t *c 15157 ** @returns xcb_get_screen_saver_cookie_t 15158 ** 15159 *****************************************************************************/ 15160 15161 xcb_get_screen_saver_cookie_t 15162 xcb_get_screen_saver (xcb_connection_t *c /**< */) 15163 { 15164 static const xcb_protocol_request_t xcb_req = { 15165 /* count */ 2, 15166 /* ext */ 0, 15167 /* opcode */ XCB_GET_SCREEN_SAVER, 15168 /* isvoid */ 0 15169 }; 15170 15171 struct iovec xcb_parts[4]; 15172 xcb_get_screen_saver_cookie_t xcb_ret; 15173 xcb_get_screen_saver_request_t xcb_out; 15174 15175 xcb_out.pad0 = 0; 15176 15177 xcb_parts[2].iov_base = (char *) &xcb_out; 15178 xcb_parts[2].iov_len = sizeof(xcb_out); 15179 xcb_parts[3].iov_base = 0; 15180 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15181 15182 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15183 return xcb_ret; 15184 } 15185 15186 15187 /***************************************************************************** 15188 ** 15189 ** xcb_get_screen_saver_cookie_t xcb_get_screen_saver_unchecked 15190 ** 15191 ** @param xcb_connection_t *c 15192 ** @returns xcb_get_screen_saver_cookie_t 15193 ** 15194 *****************************************************************************/ 15195 15196 xcb_get_screen_saver_cookie_t 15197 xcb_get_screen_saver_unchecked (xcb_connection_t *c /**< */) 15198 { 15199 static const xcb_protocol_request_t xcb_req = { 15200 /* count */ 2, 15201 /* ext */ 0, 15202 /* opcode */ XCB_GET_SCREEN_SAVER, 15203 /* isvoid */ 0 15204 }; 15205 15206 struct iovec xcb_parts[4]; 15207 xcb_get_screen_saver_cookie_t xcb_ret; 15208 xcb_get_screen_saver_request_t xcb_out; 15209 15210 xcb_out.pad0 = 0; 15211 15212 xcb_parts[2].iov_base = (char *) &xcb_out; 15213 xcb_parts[2].iov_len = sizeof(xcb_out); 15214 xcb_parts[3].iov_base = 0; 15215 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15216 15217 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15218 return xcb_ret; 15219 } 15220 15221 15222 /***************************************************************************** 15223 ** 15224 ** xcb_get_screen_saver_reply_t * xcb_get_screen_saver_reply 15225 ** 15226 ** @param xcb_connection_t *c 15227 ** @param xcb_get_screen_saver_cookie_t cookie 15228 ** @param xcb_generic_error_t **e 15229 ** @returns xcb_get_screen_saver_reply_t * 15230 ** 15231 *****************************************************************************/ 15232 15233 xcb_get_screen_saver_reply_t * 15234 xcb_get_screen_saver_reply (xcb_connection_t *c /**< */, 15235 xcb_get_screen_saver_cookie_t cookie /**< */, 15236 xcb_generic_error_t **e /**< */) 15237 { 15238 return (xcb_get_screen_saver_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15239 } 15240 15241 int 15242 xcb_change_hosts_sizeof (const void *_buffer /**< */) 15243 { 15244 char *xcb_tmp = (char *)_buffer; 15245 const xcb_change_hosts_request_t *_aux = (xcb_change_hosts_request_t *)_buffer; 15246 unsigned int xcb_buffer_len = 0; 15247 unsigned int xcb_block_len = 0; 15248 unsigned int xcb_pad = 0; 15249 unsigned int xcb_align_to; 15250 15251 15252 xcb_block_len += sizeof(xcb_change_hosts_request_t); 15253 xcb_tmp += xcb_block_len; 15254 /* address */ 15255 xcb_block_len += _aux->address_len * sizeof(uint8_t); 15256 xcb_tmp += xcb_block_len; 15257 xcb_align_to = ALIGNOF(uint8_t); 15258 /* insert padding */ 15259 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15260 xcb_buffer_len += xcb_block_len + xcb_pad; 15261 if (0 != xcb_pad) { 15262 xcb_tmp += xcb_pad; 15263 xcb_pad = 0; 15264 } 15265 xcb_block_len = 0; 15266 15267 return xcb_buffer_len; 15268 } 15269 15270 15271 /***************************************************************************** 15272 ** 15273 ** xcb_void_cookie_t xcb_change_hosts_checked 15274 ** 15275 ** @param xcb_connection_t *c 15276 ** @param uint8_t mode 15277 ** @param uint8_t family 15278 ** @param uint16_t address_len 15279 ** @param const uint8_t *address 15280 ** @returns xcb_void_cookie_t 15281 ** 15282 *****************************************************************************/ 15283 15284 xcb_void_cookie_t 15285 xcb_change_hosts_checked (xcb_connection_t *c /**< */, 15286 uint8_t mode /**< */, 15287 uint8_t family /**< */, 15288 uint16_t address_len /**< */, 15289 const uint8_t *address /**< */) 15290 { 15291 static const xcb_protocol_request_t xcb_req = { 15292 /* count */ 4, 15293 /* ext */ 0, 15294 /* opcode */ XCB_CHANGE_HOSTS, 15295 /* isvoid */ 1 15296 }; 15297 15298 struct iovec xcb_parts[6]; 15299 xcb_void_cookie_t xcb_ret; 15300 xcb_change_hosts_request_t xcb_out; 15301 15302 xcb_out.mode = mode; 15303 xcb_out.family = family; 15304 xcb_out.pad0 = 0; 15305 xcb_out.address_len = address_len; 15306 15307 xcb_parts[2].iov_base = (char *) &xcb_out; 15308 xcb_parts[2].iov_len = sizeof(xcb_out); 15309 xcb_parts[3].iov_base = 0; 15310 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15311 /* uint8_t address */ 15312 xcb_parts[4].iov_base = (char *) address; 15313 xcb_parts[4].iov_len = address_len * sizeof(uint8_t); 15314 xcb_parts[5].iov_base = 0; 15315 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 15316 15317 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15318 return xcb_ret; 15319 } 15320 15321 15322 /***************************************************************************** 15323 ** 15324 ** xcb_void_cookie_t xcb_change_hosts 15325 ** 15326 ** @param xcb_connection_t *c 15327 ** @param uint8_t mode 15328 ** @param uint8_t family 15329 ** @param uint16_t address_len 15330 ** @param const uint8_t *address 15331 ** @returns xcb_void_cookie_t 15332 ** 15333 *****************************************************************************/ 15334 15335 xcb_void_cookie_t 15336 xcb_change_hosts (xcb_connection_t *c /**< */, 15337 uint8_t mode /**< */, 15338 uint8_t family /**< */, 15339 uint16_t address_len /**< */, 15340 const uint8_t *address /**< */) 15341 { 15342 static const xcb_protocol_request_t xcb_req = { 15343 /* count */ 4, 15344 /* ext */ 0, 15345 /* opcode */ XCB_CHANGE_HOSTS, 15346 /* isvoid */ 1 15347 }; 15348 15349 struct iovec xcb_parts[6]; 15350 xcb_void_cookie_t xcb_ret; 15351 xcb_change_hosts_request_t xcb_out; 15352 15353 xcb_out.mode = mode; 15354 xcb_out.family = family; 15355 xcb_out.pad0 = 0; 15356 xcb_out.address_len = address_len; 15357 15358 xcb_parts[2].iov_base = (char *) &xcb_out; 15359 xcb_parts[2].iov_len = sizeof(xcb_out); 15360 xcb_parts[3].iov_base = 0; 15361 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15362 /* uint8_t address */ 15363 xcb_parts[4].iov_base = (char *) address; 15364 xcb_parts[4].iov_len = address_len * sizeof(uint8_t); 15365 xcb_parts[5].iov_base = 0; 15366 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 15367 15368 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15369 return xcb_ret; 15370 } 15371 15372 int 15373 xcb_host_sizeof (const void *_buffer /**< */) 15374 { 15375 char *xcb_tmp = (char *)_buffer; 15376 const xcb_host_t *_aux = (xcb_host_t *)_buffer; 15377 unsigned int xcb_buffer_len = 0; 15378 unsigned int xcb_block_len = 0; 15379 unsigned int xcb_pad = 0; 15380 unsigned int xcb_align_to; 15381 15382 15383 xcb_block_len += sizeof(xcb_host_t); 15384 xcb_tmp += xcb_block_len; 15385 /* address */ 15386 xcb_block_len += _aux->address_len * sizeof(uint8_t); 15387 xcb_tmp += xcb_block_len; 15388 xcb_align_to = ALIGNOF(uint8_t); 15389 /* insert padding */ 15390 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15391 xcb_buffer_len += xcb_block_len + xcb_pad; 15392 if (0 != xcb_pad) { 15393 xcb_tmp += xcb_pad; 15394 xcb_pad = 0; 15395 } 15396 xcb_block_len = 0; 15397 15398 return xcb_buffer_len; 15399 } 15400 15401 15402 /***************************************************************************** 15403 ** 15404 ** uint8_t * xcb_host_address 15405 ** 15406 ** @param const xcb_host_t *R 15407 ** @returns uint8_t * 15408 ** 15409 *****************************************************************************/ 15410 15411 uint8_t * 15412 xcb_host_address (const xcb_host_t *R /**< */) 15413 { 15414 return (uint8_t *) (R + 1); 15415 } 15416 15417 15418 /***************************************************************************** 15419 ** 15420 ** int xcb_host_address_length 15421 ** 15422 ** @param const xcb_host_t *R 15423 ** @returns int 15424 ** 15425 *****************************************************************************/ 15426 15427 int 15428 xcb_host_address_length (const xcb_host_t *R /**< */) 15429 { 15430 return R->address_len; 15431 } 15432 15433 15434 /***************************************************************************** 15435 ** 15436 ** xcb_generic_iterator_t xcb_host_address_end 15437 ** 15438 ** @param const xcb_host_t *R 15439 ** @returns xcb_generic_iterator_t 15440 ** 15441 *****************************************************************************/ 15442 15443 xcb_generic_iterator_t 15444 xcb_host_address_end (const xcb_host_t *R /**< */) 15445 { 15446 xcb_generic_iterator_t i; 15447 i.data = ((uint8_t *) (R + 1)) + (R->address_len); 15448 i.rem = 0; 15449 i.index = (char *) i.data - (char *) R; 15450 return i; 15451 } 15452 15453 15454 /***************************************************************************** 15455 ** 15456 ** void xcb_host_next 15457 ** 15458 ** @param xcb_host_iterator_t *i 15459 ** @returns void 15460 ** 15461 *****************************************************************************/ 15462 15463 void 15464 xcb_host_next (xcb_host_iterator_t *i /**< */) 15465 { 15466 xcb_host_t *R = i->data; 15467 xcb_generic_iterator_t child; 15468 child.data = (xcb_host_t *)(((char *)R) + xcb_host_sizeof(R)); 15469 i->index = (char *) child.data - (char *) i->data; 15470 --i->rem; 15471 i->data = (xcb_host_t *) child.data; 15472 } 15473 15474 15475 /***************************************************************************** 15476 ** 15477 ** xcb_generic_iterator_t xcb_host_end 15478 ** 15479 ** @param xcb_host_iterator_t i 15480 ** @returns xcb_generic_iterator_t 15481 ** 15482 *****************************************************************************/ 15483 15484 xcb_generic_iterator_t 15485 xcb_host_end (xcb_host_iterator_t i /**< */) 15486 { 15487 xcb_generic_iterator_t ret; 15488 while(i.rem > 0) 15489 xcb_host_next(&i); 15490 ret.data = i.data; 15491 ret.rem = i.rem; 15492 ret.index = i.index; 15493 return ret; 15494 } 15495 15496 int 15497 xcb_list_hosts_sizeof (const void *_buffer /**< */) 15498 { 15499 char *xcb_tmp = (char *)_buffer; 15500 const xcb_list_hosts_reply_t *_aux = (xcb_list_hosts_reply_t *)_buffer; 15501 unsigned int xcb_buffer_len = 0; 15502 unsigned int xcb_block_len = 0; 15503 unsigned int xcb_pad = 0; 15504 unsigned int xcb_align_to; 15505 15506 unsigned int i; 15507 unsigned int xcb_tmp_len; 15508 15509 xcb_block_len += sizeof(xcb_list_hosts_reply_t); 15510 xcb_tmp += xcb_block_len; 15511 /* hosts */ 15512 for(i=0; i<_aux->hosts_len; i++) { 15513 xcb_tmp_len = xcb_host_sizeof(xcb_tmp); 15514 xcb_block_len += xcb_tmp_len; 15515 xcb_tmp += xcb_tmp_len; 15516 } 15517 xcb_align_to = ALIGNOF(xcb_host_t); 15518 /* insert padding */ 15519 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15520 xcb_buffer_len += xcb_block_len + xcb_pad; 15521 if (0 != xcb_pad) { 15522 xcb_tmp += xcb_pad; 15523 xcb_pad = 0; 15524 } 15525 xcb_block_len = 0; 15526 15527 return xcb_buffer_len; 15528 } 15529 15530 15531 /***************************************************************************** 15532 ** 15533 ** xcb_list_hosts_cookie_t xcb_list_hosts 15534 ** 15535 ** @param xcb_connection_t *c 15536 ** @returns xcb_list_hosts_cookie_t 15537 ** 15538 *****************************************************************************/ 15539 15540 xcb_list_hosts_cookie_t 15541 xcb_list_hosts (xcb_connection_t *c /**< */) 15542 { 15543 static const xcb_protocol_request_t xcb_req = { 15544 /* count */ 2, 15545 /* ext */ 0, 15546 /* opcode */ XCB_LIST_HOSTS, 15547 /* isvoid */ 0 15548 }; 15549 15550 struct iovec xcb_parts[4]; 15551 xcb_list_hosts_cookie_t xcb_ret; 15552 xcb_list_hosts_request_t xcb_out; 15553 15554 xcb_out.pad0 = 0; 15555 15556 xcb_parts[2].iov_base = (char *) &xcb_out; 15557 xcb_parts[2].iov_len = sizeof(xcb_out); 15558 xcb_parts[3].iov_base = 0; 15559 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15560 15561 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15562 return xcb_ret; 15563 } 15564 15565 15566 /***************************************************************************** 15567 ** 15568 ** xcb_list_hosts_cookie_t xcb_list_hosts_unchecked 15569 ** 15570 ** @param xcb_connection_t *c 15571 ** @returns xcb_list_hosts_cookie_t 15572 ** 15573 *****************************************************************************/ 15574 15575 xcb_list_hosts_cookie_t 15576 xcb_list_hosts_unchecked (xcb_connection_t *c /**< */) 15577 { 15578 static const xcb_protocol_request_t xcb_req = { 15579 /* count */ 2, 15580 /* ext */ 0, 15581 /* opcode */ XCB_LIST_HOSTS, 15582 /* isvoid */ 0 15583 }; 15584 15585 struct iovec xcb_parts[4]; 15586 xcb_list_hosts_cookie_t xcb_ret; 15587 xcb_list_hosts_request_t xcb_out; 15588 15589 xcb_out.pad0 = 0; 15590 15591 xcb_parts[2].iov_base = (char *) &xcb_out; 15592 xcb_parts[2].iov_len = sizeof(xcb_out); 15593 xcb_parts[3].iov_base = 0; 15594 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15595 15596 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15597 return xcb_ret; 15598 } 15599 15600 15601 /***************************************************************************** 15602 ** 15603 ** int xcb_list_hosts_hosts_length 15604 ** 15605 ** @param const xcb_list_hosts_reply_t *R 15606 ** @returns int 15607 ** 15608 *****************************************************************************/ 15609 15610 int 15611 xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R /**< */) 15612 { 15613 return R->hosts_len; 15614 } 15615 15616 15617 /***************************************************************************** 15618 ** 15619 ** xcb_host_iterator_t xcb_list_hosts_hosts_iterator 15620 ** 15621 ** @param const xcb_list_hosts_reply_t *R 15622 ** @returns xcb_host_iterator_t 15623 ** 15624 *****************************************************************************/ 15625 15626 xcb_host_iterator_t 15627 xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R /**< */) 15628 { 15629 xcb_host_iterator_t i; 15630 i.data = (xcb_host_t *) (R + 1); 15631 i.rem = R->hosts_len; 15632 i.index = (char *) i.data - (char *) R; 15633 return i; 15634 } 15635 15636 15637 /***************************************************************************** 15638 ** 15639 ** xcb_list_hosts_reply_t * xcb_list_hosts_reply 15640 ** 15641 ** @param xcb_connection_t *c 15642 ** @param xcb_list_hosts_cookie_t cookie 15643 ** @param xcb_generic_error_t **e 15644 ** @returns xcb_list_hosts_reply_t * 15645 ** 15646 *****************************************************************************/ 15647 15648 xcb_list_hosts_reply_t * 15649 xcb_list_hosts_reply (xcb_connection_t *c /**< */, 15650 xcb_list_hosts_cookie_t cookie /**< */, 15651 xcb_generic_error_t **e /**< */) 15652 { 15653 return (xcb_list_hosts_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 15654 } 15655 15656 15657 /***************************************************************************** 15658 ** 15659 ** xcb_void_cookie_t xcb_set_access_control_checked 15660 ** 15661 ** @param xcb_connection_t *c 15662 ** @param uint8_t mode 15663 ** @returns xcb_void_cookie_t 15664 ** 15665 *****************************************************************************/ 15666 15667 xcb_void_cookie_t 15668 xcb_set_access_control_checked (xcb_connection_t *c /**< */, 15669 uint8_t mode /**< */) 15670 { 15671 static const xcb_protocol_request_t xcb_req = { 15672 /* count */ 2, 15673 /* ext */ 0, 15674 /* opcode */ XCB_SET_ACCESS_CONTROL, 15675 /* isvoid */ 1 15676 }; 15677 15678 struct iovec xcb_parts[4]; 15679 xcb_void_cookie_t xcb_ret; 15680 xcb_set_access_control_request_t xcb_out; 15681 15682 xcb_out.mode = mode; 15683 15684 xcb_parts[2].iov_base = (char *) &xcb_out; 15685 xcb_parts[2].iov_len = sizeof(xcb_out); 15686 xcb_parts[3].iov_base = 0; 15687 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15688 15689 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15690 return xcb_ret; 15691 } 15692 15693 15694 /***************************************************************************** 15695 ** 15696 ** xcb_void_cookie_t xcb_set_access_control 15697 ** 15698 ** @param xcb_connection_t *c 15699 ** @param uint8_t mode 15700 ** @returns xcb_void_cookie_t 15701 ** 15702 *****************************************************************************/ 15703 15704 xcb_void_cookie_t 15705 xcb_set_access_control (xcb_connection_t *c /**< */, 15706 uint8_t mode /**< */) 15707 { 15708 static const xcb_protocol_request_t xcb_req = { 15709 /* count */ 2, 15710 /* ext */ 0, 15711 /* opcode */ XCB_SET_ACCESS_CONTROL, 15712 /* isvoid */ 1 15713 }; 15714 15715 struct iovec xcb_parts[4]; 15716 xcb_void_cookie_t xcb_ret; 15717 xcb_set_access_control_request_t xcb_out; 15718 15719 xcb_out.mode = mode; 15720 15721 xcb_parts[2].iov_base = (char *) &xcb_out; 15722 xcb_parts[2].iov_len = sizeof(xcb_out); 15723 xcb_parts[3].iov_base = 0; 15724 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15725 15726 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15727 return xcb_ret; 15728 } 15729 15730 15731 /***************************************************************************** 15732 ** 15733 ** xcb_void_cookie_t xcb_set_close_down_mode_checked 15734 ** 15735 ** @param xcb_connection_t *c 15736 ** @param uint8_t mode 15737 ** @returns xcb_void_cookie_t 15738 ** 15739 *****************************************************************************/ 15740 15741 xcb_void_cookie_t 15742 xcb_set_close_down_mode_checked (xcb_connection_t *c /**< */, 15743 uint8_t mode /**< */) 15744 { 15745 static const xcb_protocol_request_t xcb_req = { 15746 /* count */ 2, 15747 /* ext */ 0, 15748 /* opcode */ XCB_SET_CLOSE_DOWN_MODE, 15749 /* isvoid */ 1 15750 }; 15751 15752 struct iovec xcb_parts[4]; 15753 xcb_void_cookie_t xcb_ret; 15754 xcb_set_close_down_mode_request_t xcb_out; 15755 15756 xcb_out.mode = mode; 15757 15758 xcb_parts[2].iov_base = (char *) &xcb_out; 15759 xcb_parts[2].iov_len = sizeof(xcb_out); 15760 xcb_parts[3].iov_base = 0; 15761 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15762 15763 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15764 return xcb_ret; 15765 } 15766 15767 15768 /***************************************************************************** 15769 ** 15770 ** xcb_void_cookie_t xcb_set_close_down_mode 15771 ** 15772 ** @param xcb_connection_t *c 15773 ** @param uint8_t mode 15774 ** @returns xcb_void_cookie_t 15775 ** 15776 *****************************************************************************/ 15777 15778 xcb_void_cookie_t 15779 xcb_set_close_down_mode (xcb_connection_t *c /**< */, 15780 uint8_t mode /**< */) 15781 { 15782 static const xcb_protocol_request_t xcb_req = { 15783 /* count */ 2, 15784 /* ext */ 0, 15785 /* opcode */ XCB_SET_CLOSE_DOWN_MODE, 15786 /* isvoid */ 1 15787 }; 15788 15789 struct iovec xcb_parts[4]; 15790 xcb_void_cookie_t xcb_ret; 15791 xcb_set_close_down_mode_request_t xcb_out; 15792 15793 xcb_out.mode = mode; 15794 15795 xcb_parts[2].iov_base = (char *) &xcb_out; 15796 xcb_parts[2].iov_len = sizeof(xcb_out); 15797 xcb_parts[3].iov_base = 0; 15798 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15799 15800 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15801 return xcb_ret; 15802 } 15803 15804 15805 /***************************************************************************** 15806 ** 15807 ** xcb_void_cookie_t xcb_kill_client_checked 15808 ** 15809 ** @param xcb_connection_t *c 15810 ** @param uint32_t resource 15811 ** @returns xcb_void_cookie_t 15812 ** 15813 *****************************************************************************/ 15814 15815 xcb_void_cookie_t 15816 xcb_kill_client_checked (xcb_connection_t *c /**< */, 15817 uint32_t resource /**< */) 15818 { 15819 static const xcb_protocol_request_t xcb_req = { 15820 /* count */ 2, 15821 /* ext */ 0, 15822 /* opcode */ XCB_KILL_CLIENT, 15823 /* isvoid */ 1 15824 }; 15825 15826 struct iovec xcb_parts[4]; 15827 xcb_void_cookie_t xcb_ret; 15828 xcb_kill_client_request_t xcb_out; 15829 15830 xcb_out.pad0 = 0; 15831 xcb_out.resource = resource; 15832 15833 xcb_parts[2].iov_base = (char *) &xcb_out; 15834 xcb_parts[2].iov_len = sizeof(xcb_out); 15835 xcb_parts[3].iov_base = 0; 15836 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15837 15838 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15839 return xcb_ret; 15840 } 15841 15842 15843 /***************************************************************************** 15844 ** 15845 ** xcb_void_cookie_t xcb_kill_client 15846 ** 15847 ** @param xcb_connection_t *c 15848 ** @param uint32_t resource 15849 ** @returns xcb_void_cookie_t 15850 ** 15851 *****************************************************************************/ 15852 15853 xcb_void_cookie_t 15854 xcb_kill_client (xcb_connection_t *c /**< */, 15855 uint32_t resource /**< */) 15856 { 15857 static const xcb_protocol_request_t xcb_req = { 15858 /* count */ 2, 15859 /* ext */ 0, 15860 /* opcode */ XCB_KILL_CLIENT, 15861 /* isvoid */ 1 15862 }; 15863 15864 struct iovec xcb_parts[4]; 15865 xcb_void_cookie_t xcb_ret; 15866 xcb_kill_client_request_t xcb_out; 15867 15868 xcb_out.pad0 = 0; 15869 xcb_out.resource = resource; 15870 15871 xcb_parts[2].iov_base = (char *) &xcb_out; 15872 xcb_parts[2].iov_len = sizeof(xcb_out); 15873 xcb_parts[3].iov_base = 0; 15874 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15875 15876 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 15877 return xcb_ret; 15878 } 15879 15880 int 15881 xcb_rotate_properties_sizeof (const void *_buffer /**< */) 15882 { 15883 char *xcb_tmp = (char *)_buffer; 15884 const xcb_rotate_properties_request_t *_aux = (xcb_rotate_properties_request_t *)_buffer; 15885 unsigned int xcb_buffer_len = 0; 15886 unsigned int xcb_block_len = 0; 15887 unsigned int xcb_pad = 0; 15888 unsigned int xcb_align_to; 15889 15890 15891 xcb_block_len += sizeof(xcb_rotate_properties_request_t); 15892 xcb_tmp += xcb_block_len; 15893 /* atoms */ 15894 xcb_block_len += _aux->atoms_len * sizeof(xcb_atom_t); 15895 xcb_tmp += xcb_block_len; 15896 xcb_align_to = ALIGNOF(xcb_atom_t); 15897 /* insert padding */ 15898 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 15899 xcb_buffer_len += xcb_block_len + xcb_pad; 15900 if (0 != xcb_pad) { 15901 xcb_tmp += xcb_pad; 15902 xcb_pad = 0; 15903 } 15904 xcb_block_len = 0; 15905 15906 return xcb_buffer_len; 15907 } 15908 15909 15910 /***************************************************************************** 15911 ** 15912 ** xcb_void_cookie_t xcb_rotate_properties_checked 15913 ** 15914 ** @param xcb_connection_t *c 15915 ** @param xcb_window_t window 15916 ** @param uint16_t atoms_len 15917 ** @param int16_t delta 15918 ** @param const xcb_atom_t *atoms 15919 ** @returns xcb_void_cookie_t 15920 ** 15921 *****************************************************************************/ 15922 15923 xcb_void_cookie_t 15924 xcb_rotate_properties_checked (xcb_connection_t *c /**< */, 15925 xcb_window_t window /**< */, 15926 uint16_t atoms_len /**< */, 15927 int16_t delta /**< */, 15928 const xcb_atom_t *atoms /**< */) 15929 { 15930 static const xcb_protocol_request_t xcb_req = { 15931 /* count */ 4, 15932 /* ext */ 0, 15933 /* opcode */ XCB_ROTATE_PROPERTIES, 15934 /* isvoid */ 1 15935 }; 15936 15937 struct iovec xcb_parts[6]; 15938 xcb_void_cookie_t xcb_ret; 15939 xcb_rotate_properties_request_t xcb_out; 15940 15941 xcb_out.pad0 = 0; 15942 xcb_out.window = window; 15943 xcb_out.atoms_len = atoms_len; 15944 xcb_out.delta = delta; 15945 15946 xcb_parts[2].iov_base = (char *) &xcb_out; 15947 xcb_parts[2].iov_len = sizeof(xcb_out); 15948 xcb_parts[3].iov_base = 0; 15949 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 15950 /* xcb_atom_t atoms */ 15951 xcb_parts[4].iov_base = (char *) atoms; 15952 xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t); 15953 xcb_parts[5].iov_base = 0; 15954 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 15955 15956 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 15957 return xcb_ret; 15958 } 15959 15960 15961 /***************************************************************************** 15962 ** 15963 ** xcb_void_cookie_t xcb_rotate_properties 15964 ** 15965 ** @param xcb_connection_t *c 15966 ** @param xcb_window_t window 15967 ** @param uint16_t atoms_len 15968 ** @param int16_t delta 15969 ** @param const xcb_atom_t *atoms 15970 ** @returns xcb_void_cookie_t 15971 ** 15972 *****************************************************************************/ 15973 15974 xcb_void_cookie_t 15975 xcb_rotate_properties (xcb_connection_t *c /**< */, 15976 xcb_window_t window /**< */, 15977 uint16_t atoms_len /**< */, 15978 int16_t delta /**< */, 15979 const xcb_atom_t *atoms /**< */) 15980 { 15981 static const xcb_protocol_request_t xcb_req = { 15982 /* count */ 4, 15983 /* ext */ 0, 15984 /* opcode */ XCB_ROTATE_PROPERTIES, 15985 /* isvoid */ 1 15986 }; 15987 15988 struct iovec xcb_parts[6]; 15989 xcb_void_cookie_t xcb_ret; 15990 xcb_rotate_properties_request_t xcb_out; 15991 15992 xcb_out.pad0 = 0; 15993 xcb_out.window = window; 15994 xcb_out.atoms_len = atoms_len; 15995 xcb_out.delta = delta; 15996 15997 xcb_parts[2].iov_base = (char *) &xcb_out; 15998 xcb_parts[2].iov_len = sizeof(xcb_out); 15999 xcb_parts[3].iov_base = 0; 16000 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16001 /* xcb_atom_t atoms */ 16002 xcb_parts[4].iov_base = (char *) atoms; 16003 xcb_parts[4].iov_len = atoms_len * sizeof(xcb_atom_t); 16004 xcb_parts[5].iov_base = 0; 16005 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 16006 16007 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16008 return xcb_ret; 16009 } 16010 16011 16012 /***************************************************************************** 16013 ** 16014 ** xcb_void_cookie_t xcb_force_screen_saver_checked 16015 ** 16016 ** @param xcb_connection_t *c 16017 ** @param uint8_t mode 16018 ** @returns xcb_void_cookie_t 16019 ** 16020 *****************************************************************************/ 16021 16022 xcb_void_cookie_t 16023 xcb_force_screen_saver_checked (xcb_connection_t *c /**< */, 16024 uint8_t mode /**< */) 16025 { 16026 static const xcb_protocol_request_t xcb_req = { 16027 /* count */ 2, 16028 /* ext */ 0, 16029 /* opcode */ XCB_FORCE_SCREEN_SAVER, 16030 /* isvoid */ 1 16031 }; 16032 16033 struct iovec xcb_parts[4]; 16034 xcb_void_cookie_t xcb_ret; 16035 xcb_force_screen_saver_request_t xcb_out; 16036 16037 xcb_out.mode = mode; 16038 16039 xcb_parts[2].iov_base = (char *) &xcb_out; 16040 xcb_parts[2].iov_len = sizeof(xcb_out); 16041 xcb_parts[3].iov_base = 0; 16042 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16043 16044 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16045 return xcb_ret; 16046 } 16047 16048 16049 /***************************************************************************** 16050 ** 16051 ** xcb_void_cookie_t xcb_force_screen_saver 16052 ** 16053 ** @param xcb_connection_t *c 16054 ** @param uint8_t mode 16055 ** @returns xcb_void_cookie_t 16056 ** 16057 *****************************************************************************/ 16058 16059 xcb_void_cookie_t 16060 xcb_force_screen_saver (xcb_connection_t *c /**< */, 16061 uint8_t mode /**< */) 16062 { 16063 static const xcb_protocol_request_t xcb_req = { 16064 /* count */ 2, 16065 /* ext */ 0, 16066 /* opcode */ XCB_FORCE_SCREEN_SAVER, 16067 /* isvoid */ 1 16068 }; 16069 16070 struct iovec xcb_parts[4]; 16071 xcb_void_cookie_t xcb_ret; 16072 xcb_force_screen_saver_request_t xcb_out; 16073 16074 xcb_out.mode = mode; 16075 16076 xcb_parts[2].iov_base = (char *) &xcb_out; 16077 xcb_parts[2].iov_len = sizeof(xcb_out); 16078 xcb_parts[3].iov_base = 0; 16079 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16080 16081 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16082 return xcb_ret; 16083 } 16084 16085 int 16086 xcb_set_pointer_mapping_sizeof (const void *_buffer /**< */) 16087 { 16088 char *xcb_tmp = (char *)_buffer; 16089 const xcb_set_pointer_mapping_request_t *_aux = (xcb_set_pointer_mapping_request_t *)_buffer; 16090 unsigned int xcb_buffer_len = 0; 16091 unsigned int xcb_block_len = 0; 16092 unsigned int xcb_pad = 0; 16093 unsigned int xcb_align_to; 16094 16095 16096 xcb_block_len += sizeof(xcb_set_pointer_mapping_request_t); 16097 xcb_tmp += xcb_block_len; 16098 /* map */ 16099 xcb_block_len += _aux->map_len * sizeof(uint8_t); 16100 xcb_tmp += xcb_block_len; 16101 xcb_align_to = ALIGNOF(uint8_t); 16102 /* insert padding */ 16103 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 16104 xcb_buffer_len += xcb_block_len + xcb_pad; 16105 if (0 != xcb_pad) { 16106 xcb_tmp += xcb_pad; 16107 xcb_pad = 0; 16108 } 16109 xcb_block_len = 0; 16110 16111 return xcb_buffer_len; 16112 } 16113 16114 16115 /***************************************************************************** 16116 ** 16117 ** xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping 16118 ** 16119 ** @param xcb_connection_t *c 16120 ** @param uint8_t map_len 16121 ** @param const uint8_t *map 16122 ** @returns xcb_set_pointer_mapping_cookie_t 16123 ** 16124 *****************************************************************************/ 16125 16126 xcb_set_pointer_mapping_cookie_t 16127 xcb_set_pointer_mapping (xcb_connection_t *c /**< */, 16128 uint8_t map_len /**< */, 16129 const uint8_t *map /**< */) 16130 { 16131 static const xcb_protocol_request_t xcb_req = { 16132 /* count */ 4, 16133 /* ext */ 0, 16134 /* opcode */ XCB_SET_POINTER_MAPPING, 16135 /* isvoid */ 0 16136 }; 16137 16138 struct iovec xcb_parts[6]; 16139 xcb_set_pointer_mapping_cookie_t xcb_ret; 16140 xcb_set_pointer_mapping_request_t xcb_out; 16141 16142 xcb_out.map_len = map_len; 16143 16144 xcb_parts[2].iov_base = (char *) &xcb_out; 16145 xcb_parts[2].iov_len = sizeof(xcb_out); 16146 xcb_parts[3].iov_base = 0; 16147 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16148 /* uint8_t map */ 16149 xcb_parts[4].iov_base = (char *) map; 16150 xcb_parts[4].iov_len = map_len * sizeof(uint8_t); 16151 xcb_parts[5].iov_base = 0; 16152 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 16153 16154 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16155 return xcb_ret; 16156 } 16157 16158 16159 /***************************************************************************** 16160 ** 16161 ** xcb_set_pointer_mapping_cookie_t xcb_set_pointer_mapping_unchecked 16162 ** 16163 ** @param xcb_connection_t *c 16164 ** @param uint8_t map_len 16165 ** @param const uint8_t *map 16166 ** @returns xcb_set_pointer_mapping_cookie_t 16167 ** 16168 *****************************************************************************/ 16169 16170 xcb_set_pointer_mapping_cookie_t 16171 xcb_set_pointer_mapping_unchecked (xcb_connection_t *c /**< */, 16172 uint8_t map_len /**< */, 16173 const uint8_t *map /**< */) 16174 { 16175 static const xcb_protocol_request_t xcb_req = { 16176 /* count */ 4, 16177 /* ext */ 0, 16178 /* opcode */ XCB_SET_POINTER_MAPPING, 16179 /* isvoid */ 0 16180 }; 16181 16182 struct iovec xcb_parts[6]; 16183 xcb_set_pointer_mapping_cookie_t xcb_ret; 16184 xcb_set_pointer_mapping_request_t xcb_out; 16185 16186 xcb_out.map_len = map_len; 16187 16188 xcb_parts[2].iov_base = (char *) &xcb_out; 16189 xcb_parts[2].iov_len = sizeof(xcb_out); 16190 xcb_parts[3].iov_base = 0; 16191 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16192 /* uint8_t map */ 16193 xcb_parts[4].iov_base = (char *) map; 16194 xcb_parts[4].iov_len = map_len * sizeof(uint8_t); 16195 xcb_parts[5].iov_base = 0; 16196 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 16197 16198 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16199 return xcb_ret; 16200 } 16201 16202 16203 /***************************************************************************** 16204 ** 16205 ** xcb_set_pointer_mapping_reply_t * xcb_set_pointer_mapping_reply 16206 ** 16207 ** @param xcb_connection_t *c 16208 ** @param xcb_set_pointer_mapping_cookie_t cookie 16209 ** @param xcb_generic_error_t **e 16210 ** @returns xcb_set_pointer_mapping_reply_t * 16211 ** 16212 *****************************************************************************/ 16213 16214 xcb_set_pointer_mapping_reply_t * 16215 xcb_set_pointer_mapping_reply (xcb_connection_t *c /**< */, 16216 xcb_set_pointer_mapping_cookie_t cookie /**< */, 16217 xcb_generic_error_t **e /**< */) 16218 { 16219 return (xcb_set_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 16220 } 16221 16222 int 16223 xcb_get_pointer_mapping_sizeof (const void *_buffer /**< */) 16224 { 16225 char *xcb_tmp = (char *)_buffer; 16226 const xcb_get_pointer_mapping_reply_t *_aux = (xcb_get_pointer_mapping_reply_t *)_buffer; 16227 unsigned int xcb_buffer_len = 0; 16228 unsigned int xcb_block_len = 0; 16229 unsigned int xcb_pad = 0; 16230 unsigned int xcb_align_to; 16231 16232 16233 xcb_block_len += sizeof(xcb_get_pointer_mapping_reply_t); 16234 xcb_tmp += xcb_block_len; 16235 /* map */ 16236 xcb_block_len += _aux->map_len * sizeof(uint8_t); 16237 xcb_tmp += xcb_block_len; 16238 xcb_align_to = ALIGNOF(uint8_t); 16239 /* insert padding */ 16240 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 16241 xcb_buffer_len += xcb_block_len + xcb_pad; 16242 if (0 != xcb_pad) { 16243 xcb_tmp += xcb_pad; 16244 xcb_pad = 0; 16245 } 16246 xcb_block_len = 0; 16247 16248 return xcb_buffer_len; 16249 } 16250 16251 16252 /***************************************************************************** 16253 ** 16254 ** xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping 16255 ** 16256 ** @param xcb_connection_t *c 16257 ** @returns xcb_get_pointer_mapping_cookie_t 16258 ** 16259 *****************************************************************************/ 16260 16261 xcb_get_pointer_mapping_cookie_t 16262 xcb_get_pointer_mapping (xcb_connection_t *c /**< */) 16263 { 16264 static const xcb_protocol_request_t xcb_req = { 16265 /* count */ 2, 16266 /* ext */ 0, 16267 /* opcode */ XCB_GET_POINTER_MAPPING, 16268 /* isvoid */ 0 16269 }; 16270 16271 struct iovec xcb_parts[4]; 16272 xcb_get_pointer_mapping_cookie_t xcb_ret; 16273 xcb_get_pointer_mapping_request_t xcb_out; 16274 16275 xcb_out.pad0 = 0; 16276 16277 xcb_parts[2].iov_base = (char *) &xcb_out; 16278 xcb_parts[2].iov_len = sizeof(xcb_out); 16279 xcb_parts[3].iov_base = 0; 16280 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16281 16282 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16283 return xcb_ret; 16284 } 16285 16286 16287 /***************************************************************************** 16288 ** 16289 ** xcb_get_pointer_mapping_cookie_t xcb_get_pointer_mapping_unchecked 16290 ** 16291 ** @param xcb_connection_t *c 16292 ** @returns xcb_get_pointer_mapping_cookie_t 16293 ** 16294 *****************************************************************************/ 16295 16296 xcb_get_pointer_mapping_cookie_t 16297 xcb_get_pointer_mapping_unchecked (xcb_connection_t *c /**< */) 16298 { 16299 static const xcb_protocol_request_t xcb_req = { 16300 /* count */ 2, 16301 /* ext */ 0, 16302 /* opcode */ XCB_GET_POINTER_MAPPING, 16303 /* isvoid */ 0 16304 }; 16305 16306 struct iovec xcb_parts[4]; 16307 xcb_get_pointer_mapping_cookie_t xcb_ret; 16308 xcb_get_pointer_mapping_request_t xcb_out; 16309 16310 xcb_out.pad0 = 0; 16311 16312 xcb_parts[2].iov_base = (char *) &xcb_out; 16313 xcb_parts[2].iov_len = sizeof(xcb_out); 16314 xcb_parts[3].iov_base = 0; 16315 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16316 16317 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16318 return xcb_ret; 16319 } 16320 16321 16322 /***************************************************************************** 16323 ** 16324 ** uint8_t * xcb_get_pointer_mapping_map 16325 ** 16326 ** @param const xcb_get_pointer_mapping_reply_t *R 16327 ** @returns uint8_t * 16328 ** 16329 *****************************************************************************/ 16330 16331 uint8_t * 16332 xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R /**< */) 16333 { 16334 return (uint8_t *) (R + 1); 16335 } 16336 16337 16338 /***************************************************************************** 16339 ** 16340 ** int xcb_get_pointer_mapping_map_length 16341 ** 16342 ** @param const xcb_get_pointer_mapping_reply_t *R 16343 ** @returns int 16344 ** 16345 *****************************************************************************/ 16346 16347 int 16348 xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R /**< */) 16349 { 16350 return R->map_len; 16351 } 16352 16353 16354 /***************************************************************************** 16355 ** 16356 ** xcb_generic_iterator_t xcb_get_pointer_mapping_map_end 16357 ** 16358 ** @param const xcb_get_pointer_mapping_reply_t *R 16359 ** @returns xcb_generic_iterator_t 16360 ** 16361 *****************************************************************************/ 16362 16363 xcb_generic_iterator_t 16364 xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R /**< */) 16365 { 16366 xcb_generic_iterator_t i; 16367 i.data = ((uint8_t *) (R + 1)) + (R->map_len); 16368 i.rem = 0; 16369 i.index = (char *) i.data - (char *) R; 16370 return i; 16371 } 16372 16373 16374 /***************************************************************************** 16375 ** 16376 ** xcb_get_pointer_mapping_reply_t * xcb_get_pointer_mapping_reply 16377 ** 16378 ** @param xcb_connection_t *c 16379 ** @param xcb_get_pointer_mapping_cookie_t cookie 16380 ** @param xcb_generic_error_t **e 16381 ** @returns xcb_get_pointer_mapping_reply_t * 16382 ** 16383 *****************************************************************************/ 16384 16385 xcb_get_pointer_mapping_reply_t * 16386 xcb_get_pointer_mapping_reply (xcb_connection_t *c /**< */, 16387 xcb_get_pointer_mapping_cookie_t cookie /**< */, 16388 xcb_generic_error_t **e /**< */) 16389 { 16390 return (xcb_get_pointer_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 16391 } 16392 16393 int 16394 xcb_set_modifier_mapping_sizeof (const void *_buffer /**< */) 16395 { 16396 char *xcb_tmp = (char *)_buffer; 16397 const xcb_set_modifier_mapping_request_t *_aux = (xcb_set_modifier_mapping_request_t *)_buffer; 16398 unsigned int xcb_buffer_len = 0; 16399 unsigned int xcb_block_len = 0; 16400 unsigned int xcb_pad = 0; 16401 unsigned int xcb_align_to; 16402 16403 16404 xcb_block_len += sizeof(xcb_set_modifier_mapping_request_t); 16405 xcb_tmp += xcb_block_len; 16406 /* keycodes */ 16407 xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t); 16408 xcb_tmp += xcb_block_len; 16409 xcb_align_to = ALIGNOF(xcb_keycode_t); 16410 /* insert padding */ 16411 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 16412 xcb_buffer_len += xcb_block_len + xcb_pad; 16413 if (0 != xcb_pad) { 16414 xcb_tmp += xcb_pad; 16415 xcb_pad = 0; 16416 } 16417 xcb_block_len = 0; 16418 16419 return xcb_buffer_len; 16420 } 16421 16422 16423 /***************************************************************************** 16424 ** 16425 ** xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping 16426 ** 16427 ** @param xcb_connection_t *c 16428 ** @param uint8_t keycodes_per_modifier 16429 ** @param const xcb_keycode_t *keycodes 16430 ** @returns xcb_set_modifier_mapping_cookie_t 16431 ** 16432 *****************************************************************************/ 16433 16434 xcb_set_modifier_mapping_cookie_t 16435 xcb_set_modifier_mapping (xcb_connection_t *c /**< */, 16436 uint8_t keycodes_per_modifier /**< */, 16437 const xcb_keycode_t *keycodes /**< */) 16438 { 16439 static const xcb_protocol_request_t xcb_req = { 16440 /* count */ 4, 16441 /* ext */ 0, 16442 /* opcode */ XCB_SET_MODIFIER_MAPPING, 16443 /* isvoid */ 0 16444 }; 16445 16446 struct iovec xcb_parts[6]; 16447 xcb_set_modifier_mapping_cookie_t xcb_ret; 16448 xcb_set_modifier_mapping_request_t xcb_out; 16449 16450 xcb_out.keycodes_per_modifier = keycodes_per_modifier; 16451 16452 xcb_parts[2].iov_base = (char *) &xcb_out; 16453 xcb_parts[2].iov_len = sizeof(xcb_out); 16454 xcb_parts[3].iov_base = 0; 16455 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16456 /* xcb_keycode_t keycodes */ 16457 xcb_parts[4].iov_base = (char *) keycodes; 16458 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); 16459 xcb_parts[5].iov_base = 0; 16460 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 16461 16462 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16463 return xcb_ret; 16464 } 16465 16466 16467 /***************************************************************************** 16468 ** 16469 ** xcb_set_modifier_mapping_cookie_t xcb_set_modifier_mapping_unchecked 16470 ** 16471 ** @param xcb_connection_t *c 16472 ** @param uint8_t keycodes_per_modifier 16473 ** @param const xcb_keycode_t *keycodes 16474 ** @returns xcb_set_modifier_mapping_cookie_t 16475 ** 16476 *****************************************************************************/ 16477 16478 xcb_set_modifier_mapping_cookie_t 16479 xcb_set_modifier_mapping_unchecked (xcb_connection_t *c /**< */, 16480 uint8_t keycodes_per_modifier /**< */, 16481 const xcb_keycode_t *keycodes /**< */) 16482 { 16483 static const xcb_protocol_request_t xcb_req = { 16484 /* count */ 4, 16485 /* ext */ 0, 16486 /* opcode */ XCB_SET_MODIFIER_MAPPING, 16487 /* isvoid */ 0 16488 }; 16489 16490 struct iovec xcb_parts[6]; 16491 xcb_set_modifier_mapping_cookie_t xcb_ret; 16492 xcb_set_modifier_mapping_request_t xcb_out; 16493 16494 xcb_out.keycodes_per_modifier = keycodes_per_modifier; 16495 16496 xcb_parts[2].iov_base = (char *) &xcb_out; 16497 xcb_parts[2].iov_len = sizeof(xcb_out); 16498 xcb_parts[3].iov_base = 0; 16499 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16500 /* xcb_keycode_t keycodes */ 16501 xcb_parts[4].iov_base = (char *) keycodes; 16502 xcb_parts[4].iov_len = (keycodes_per_modifier * 8) * sizeof(uint8_t); 16503 xcb_parts[5].iov_base = 0; 16504 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 16505 16506 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16507 return xcb_ret; 16508 } 16509 16510 16511 /***************************************************************************** 16512 ** 16513 ** xcb_set_modifier_mapping_reply_t * xcb_set_modifier_mapping_reply 16514 ** 16515 ** @param xcb_connection_t *c 16516 ** @param xcb_set_modifier_mapping_cookie_t cookie 16517 ** @param xcb_generic_error_t **e 16518 ** @returns xcb_set_modifier_mapping_reply_t * 16519 ** 16520 *****************************************************************************/ 16521 16522 xcb_set_modifier_mapping_reply_t * 16523 xcb_set_modifier_mapping_reply (xcb_connection_t *c /**< */, 16524 xcb_set_modifier_mapping_cookie_t cookie /**< */, 16525 xcb_generic_error_t **e /**< */) 16526 { 16527 return (xcb_set_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 16528 } 16529 16530 int 16531 xcb_get_modifier_mapping_sizeof (const void *_buffer /**< */) 16532 { 16533 char *xcb_tmp = (char *)_buffer; 16534 const xcb_get_modifier_mapping_reply_t *_aux = (xcb_get_modifier_mapping_reply_t *)_buffer; 16535 unsigned int xcb_buffer_len = 0; 16536 unsigned int xcb_block_len = 0; 16537 unsigned int xcb_pad = 0; 16538 unsigned int xcb_align_to; 16539 16540 16541 xcb_block_len += sizeof(xcb_get_modifier_mapping_reply_t); 16542 xcb_tmp += xcb_block_len; 16543 /* keycodes */ 16544 xcb_block_len += (_aux->keycodes_per_modifier * 8) * sizeof(xcb_keycode_t); 16545 xcb_tmp += xcb_block_len; 16546 xcb_align_to = ALIGNOF(xcb_keycode_t); 16547 /* insert padding */ 16548 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 16549 xcb_buffer_len += xcb_block_len + xcb_pad; 16550 if (0 != xcb_pad) { 16551 xcb_tmp += xcb_pad; 16552 xcb_pad = 0; 16553 } 16554 xcb_block_len = 0; 16555 16556 return xcb_buffer_len; 16557 } 16558 16559 16560 /***************************************************************************** 16561 ** 16562 ** xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping 16563 ** 16564 ** @param xcb_connection_t *c 16565 ** @returns xcb_get_modifier_mapping_cookie_t 16566 ** 16567 *****************************************************************************/ 16568 16569 xcb_get_modifier_mapping_cookie_t 16570 xcb_get_modifier_mapping (xcb_connection_t *c /**< */) 16571 { 16572 static const xcb_protocol_request_t xcb_req = { 16573 /* count */ 2, 16574 /* ext */ 0, 16575 /* opcode */ XCB_GET_MODIFIER_MAPPING, 16576 /* isvoid */ 0 16577 }; 16578 16579 struct iovec xcb_parts[4]; 16580 xcb_get_modifier_mapping_cookie_t xcb_ret; 16581 xcb_get_modifier_mapping_request_t xcb_out; 16582 16583 xcb_out.pad0 = 0; 16584 16585 xcb_parts[2].iov_base = (char *) &xcb_out; 16586 xcb_parts[2].iov_len = sizeof(xcb_out); 16587 xcb_parts[3].iov_base = 0; 16588 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16589 16590 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16591 return xcb_ret; 16592 } 16593 16594 16595 /***************************************************************************** 16596 ** 16597 ** xcb_get_modifier_mapping_cookie_t xcb_get_modifier_mapping_unchecked 16598 ** 16599 ** @param xcb_connection_t *c 16600 ** @returns xcb_get_modifier_mapping_cookie_t 16601 ** 16602 *****************************************************************************/ 16603 16604 xcb_get_modifier_mapping_cookie_t 16605 xcb_get_modifier_mapping_unchecked (xcb_connection_t *c /**< */) 16606 { 16607 static const xcb_protocol_request_t xcb_req = { 16608 /* count */ 2, 16609 /* ext */ 0, 16610 /* opcode */ XCB_GET_MODIFIER_MAPPING, 16611 /* isvoid */ 0 16612 }; 16613 16614 struct iovec xcb_parts[4]; 16615 xcb_get_modifier_mapping_cookie_t xcb_ret; 16616 xcb_get_modifier_mapping_request_t xcb_out; 16617 16618 xcb_out.pad0 = 0; 16619 16620 xcb_parts[2].iov_base = (char *) &xcb_out; 16621 xcb_parts[2].iov_len = sizeof(xcb_out); 16622 xcb_parts[3].iov_base = 0; 16623 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16624 16625 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16626 return xcb_ret; 16627 } 16628 16629 16630 /***************************************************************************** 16631 ** 16632 ** xcb_keycode_t * xcb_get_modifier_mapping_keycodes 16633 ** 16634 ** @param const xcb_get_modifier_mapping_reply_t *R 16635 ** @returns xcb_keycode_t * 16636 ** 16637 *****************************************************************************/ 16638 16639 xcb_keycode_t * 16640 xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R /**< */) 16641 { 16642 return (xcb_keycode_t *) (R + 1); 16643 } 16644 16645 16646 /***************************************************************************** 16647 ** 16648 ** int xcb_get_modifier_mapping_keycodes_length 16649 ** 16650 ** @param const xcb_get_modifier_mapping_reply_t *R 16651 ** @returns int 16652 ** 16653 *****************************************************************************/ 16654 16655 int 16656 xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R /**< */) 16657 { 16658 return (R->keycodes_per_modifier * 8); 16659 } 16660 16661 16662 /***************************************************************************** 16663 ** 16664 ** xcb_generic_iterator_t xcb_get_modifier_mapping_keycodes_end 16665 ** 16666 ** @param const xcb_get_modifier_mapping_reply_t *R 16667 ** @returns xcb_generic_iterator_t 16668 ** 16669 *****************************************************************************/ 16670 16671 xcb_generic_iterator_t 16672 xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R /**< */) 16673 { 16674 xcb_generic_iterator_t i; 16675 i.data = ((xcb_keycode_t *) (R + 1)) + ((R->keycodes_per_modifier * 8)); 16676 i.rem = 0; 16677 i.index = (char *) i.data - (char *) R; 16678 return i; 16679 } 16680 16681 16682 /***************************************************************************** 16683 ** 16684 ** xcb_get_modifier_mapping_reply_t * xcb_get_modifier_mapping_reply 16685 ** 16686 ** @param xcb_connection_t *c 16687 ** @param xcb_get_modifier_mapping_cookie_t cookie 16688 ** @param xcb_generic_error_t **e 16689 ** @returns xcb_get_modifier_mapping_reply_t * 16690 ** 16691 *****************************************************************************/ 16692 16693 xcb_get_modifier_mapping_reply_t * 16694 xcb_get_modifier_mapping_reply (xcb_connection_t *c /**< */, 16695 xcb_get_modifier_mapping_cookie_t cookie /**< */, 16696 xcb_generic_error_t **e /**< */) 16697 { 16698 return (xcb_get_modifier_mapping_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 16699 } 16700 16701 16702 /***************************************************************************** 16703 ** 16704 ** xcb_void_cookie_t xcb_no_operation_checked 16705 ** 16706 ** @param xcb_connection_t *c 16707 ** @returns xcb_void_cookie_t 16708 ** 16709 *****************************************************************************/ 16710 16711 xcb_void_cookie_t 16712 xcb_no_operation_checked (xcb_connection_t *c /**< */) 16713 { 16714 static const xcb_protocol_request_t xcb_req = { 16715 /* count */ 2, 16716 /* ext */ 0, 16717 /* opcode */ XCB_NO_OPERATION, 16718 /* isvoid */ 1 16719 }; 16720 16721 struct iovec xcb_parts[4]; 16722 xcb_void_cookie_t xcb_ret; 16723 xcb_no_operation_request_t xcb_out; 16724 16725 xcb_out.pad0 = 0; 16726 16727 xcb_parts[2].iov_base = (char *) &xcb_out; 16728 xcb_parts[2].iov_len = sizeof(xcb_out); 16729 xcb_parts[3].iov_base = 0; 16730 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16731 16732 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 16733 return xcb_ret; 16734 } 16735 16736 16737 /***************************************************************************** 16738 ** 16739 ** xcb_void_cookie_t xcb_no_operation 16740 ** 16741 ** @param xcb_connection_t *c 16742 ** @returns xcb_void_cookie_t 16743 ** 16744 *****************************************************************************/ 16745 16746 xcb_void_cookie_t 16747 xcb_no_operation (xcb_connection_t *c /**< */) 16748 { 16749 static const xcb_protocol_request_t xcb_req = { 16750 /* count */ 2, 16751 /* ext */ 0, 16752 /* opcode */ XCB_NO_OPERATION, 16753 /* isvoid */ 1 16754 }; 16755 16756 struct iovec xcb_parts[4]; 16757 xcb_void_cookie_t xcb_ret; 16758 xcb_no_operation_request_t xcb_out; 16759 16760 xcb_out.pad0 = 0; 16761 16762 xcb_parts[2].iov_base = (char *) &xcb_out; 16763 xcb_parts[2].iov_len = sizeof(xcb_out); 16764 xcb_parts[3].iov_base = 0; 16765 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 16766 16767 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 16768 return xcb_ret; 16769 } 16770 16771