1 /* 2 * This file generated automatically from res.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 "res.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_res_id = { "X-Resource", 0 }; 20 21 void 22 xcb_res_client_next (xcb_res_client_iterator_t *i) 23 { 24 --i->rem; 25 ++i->data; 26 i->index += sizeof(xcb_res_client_t); 27 } 28 29 xcb_generic_iterator_t 30 xcb_res_client_end (xcb_res_client_iterator_t i) 31 { 32 xcb_generic_iterator_t ret; 33 ret.data = i.data + i.rem; 34 ret.index = i.index + ((char *) ret.data - (char *) i.data); 35 ret.rem = 0; 36 return ret; 37 } 38 39 void 40 xcb_res_type_next (xcb_res_type_iterator_t *i) 41 { 42 --i->rem; 43 ++i->data; 44 i->index += sizeof(xcb_res_type_t); 45 } 46 47 xcb_generic_iterator_t 48 xcb_res_type_end (xcb_res_type_iterator_t i) 49 { 50 xcb_generic_iterator_t ret; 51 ret.data = i.data + i.rem; 52 ret.index = i.index + ((char *) ret.data - (char *) i.data); 53 ret.rem = 0; 54 return ret; 55 } 56 57 void 58 xcb_res_client_id_spec_next (xcb_res_client_id_spec_iterator_t *i) 59 { 60 --i->rem; 61 ++i->data; 62 i->index += sizeof(xcb_res_client_id_spec_t); 63 } 64 65 xcb_generic_iterator_t 66 xcb_res_client_id_spec_end (xcb_res_client_id_spec_iterator_t i) 67 { 68 xcb_generic_iterator_t ret; 69 ret.data = i.data + i.rem; 70 ret.index = i.index + ((char *) ret.data - (char *) i.data); 71 ret.rem = 0; 72 return ret; 73 } 74 75 int 76 xcb_res_client_id_value_sizeof (const void *_buffer) 77 { 78 char *xcb_tmp = (char *)_buffer; 79 const xcb_res_client_id_value_t *_aux = (xcb_res_client_id_value_t *)_buffer; 80 unsigned int xcb_buffer_len = 0; 81 unsigned int xcb_block_len = 0; 82 unsigned int xcb_pad = 0; 83 unsigned int xcb_align_to = 0; 84 85 86 xcb_block_len += sizeof(xcb_res_client_id_value_t); 87 xcb_tmp += xcb_block_len; 88 xcb_buffer_len += xcb_block_len; 89 xcb_block_len = 0; 90 /* value */ 91 xcb_block_len += (_aux->length / 4) * sizeof(uint32_t); 92 xcb_tmp += xcb_block_len; 93 xcb_align_to = ALIGNOF(uint32_t); 94 /* insert padding */ 95 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 96 xcb_buffer_len += xcb_block_len + xcb_pad; 97 if (0 != xcb_pad) { 98 xcb_tmp += xcb_pad; 99 xcb_pad = 0; 100 } 101 xcb_block_len = 0; 102 103 return xcb_buffer_len; 104 } 105 106 uint32_t * 107 xcb_res_client_id_value_value (const xcb_res_client_id_value_t *R) 108 { 109 return (uint32_t *) (R + 1); 110 } 111 112 int 113 xcb_res_client_id_value_value_length (const xcb_res_client_id_value_t *R) 114 { 115 return (R->length / 4); 116 } 117 118 xcb_generic_iterator_t 119 xcb_res_client_id_value_value_end (const xcb_res_client_id_value_t *R) 120 { 121 xcb_generic_iterator_t i; 122 i.data = ((uint32_t *) (R + 1)) + ((R->length / 4)); 123 i.rem = 0; 124 i.index = (char *) i.data - (char *) R; 125 return i; 126 } 127 128 void 129 xcb_res_client_id_value_next (xcb_res_client_id_value_iterator_t *i) 130 { 131 xcb_res_client_id_value_t *R = i->data; 132 xcb_generic_iterator_t child; 133 child.data = (xcb_res_client_id_value_t *)(((char *)R) + xcb_res_client_id_value_sizeof(R)); 134 i->index = (char *) child.data - (char *) i->data; 135 --i->rem; 136 i->data = (xcb_res_client_id_value_t *) child.data; 137 } 138 139 xcb_generic_iterator_t 140 xcb_res_client_id_value_end (xcb_res_client_id_value_iterator_t i) 141 { 142 xcb_generic_iterator_t ret; 143 while(i.rem > 0) 144 xcb_res_client_id_value_next(&i); 145 ret.data = i.data; 146 ret.rem = i.rem; 147 ret.index = i.index; 148 return ret; 149 } 150 151 void 152 xcb_res_resource_id_spec_next (xcb_res_resource_id_spec_iterator_t *i) 153 { 154 --i->rem; 155 ++i->data; 156 i->index += sizeof(xcb_res_resource_id_spec_t); 157 } 158 159 xcb_generic_iterator_t 160 xcb_res_resource_id_spec_end (xcb_res_resource_id_spec_iterator_t i) 161 { 162 xcb_generic_iterator_t ret; 163 ret.data = i.data + i.rem; 164 ret.index = i.index + ((char *) ret.data - (char *) i.data); 165 ret.rem = 0; 166 return ret; 167 } 168 169 void 170 xcb_res_resource_size_spec_next (xcb_res_resource_size_spec_iterator_t *i) 171 { 172 --i->rem; 173 ++i->data; 174 i->index += sizeof(xcb_res_resource_size_spec_t); 175 } 176 177 xcb_generic_iterator_t 178 xcb_res_resource_size_spec_end (xcb_res_resource_size_spec_iterator_t i) 179 { 180 xcb_generic_iterator_t ret; 181 ret.data = i.data + i.rem; 182 ret.index = i.index + ((char *) ret.data - (char *) i.data); 183 ret.rem = 0; 184 return ret; 185 } 186 187 int 188 xcb_res_resource_size_value_sizeof (const void *_buffer) 189 { 190 char *xcb_tmp = (char *)_buffer; 191 const xcb_res_resource_size_value_t *_aux = (xcb_res_resource_size_value_t *)_buffer; 192 unsigned int xcb_buffer_len = 0; 193 unsigned int xcb_block_len = 0; 194 unsigned int xcb_pad = 0; 195 unsigned int xcb_align_to = 0; 196 197 198 xcb_block_len += sizeof(xcb_res_resource_size_value_t); 199 xcb_tmp += xcb_block_len; 200 xcb_buffer_len += xcb_block_len; 201 xcb_block_len = 0; 202 /* cross_references */ 203 xcb_block_len += _aux->num_cross_references * sizeof(xcb_res_resource_size_spec_t); 204 xcb_tmp += xcb_block_len; 205 xcb_align_to = ALIGNOF(xcb_res_resource_size_spec_t); 206 /* insert padding */ 207 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 208 xcb_buffer_len += xcb_block_len + xcb_pad; 209 if (0 != xcb_pad) { 210 xcb_tmp += xcb_pad; 211 xcb_pad = 0; 212 } 213 xcb_block_len = 0; 214 215 return xcb_buffer_len; 216 } 217 218 xcb_res_resource_size_spec_t * 219 xcb_res_resource_size_value_cross_references (const xcb_res_resource_size_value_t *R) 220 { 221 return (xcb_res_resource_size_spec_t *) (R + 1); 222 } 223 224 int 225 xcb_res_resource_size_value_cross_references_length (const xcb_res_resource_size_value_t *R) 226 { 227 return R->num_cross_references; 228 } 229 230 xcb_res_resource_size_spec_iterator_t 231 xcb_res_resource_size_value_cross_references_iterator (const xcb_res_resource_size_value_t *R) 232 { 233 xcb_res_resource_size_spec_iterator_t i; 234 i.data = (xcb_res_resource_size_spec_t *) (R + 1); 235 i.rem = R->num_cross_references; 236 i.index = (char *) i.data - (char *) R; 237 return i; 238 } 239 240 void 241 xcb_res_resource_size_value_next (xcb_res_resource_size_value_iterator_t *i) 242 { 243 xcb_res_resource_size_value_t *R = i->data; 244 xcb_generic_iterator_t child; 245 child.data = (xcb_res_resource_size_value_t *)(((char *)R) + xcb_res_resource_size_value_sizeof(R)); 246 i->index = (char *) child.data - (char *) i->data; 247 --i->rem; 248 i->data = (xcb_res_resource_size_value_t *) child.data; 249 } 250 251 xcb_generic_iterator_t 252 xcb_res_resource_size_value_end (xcb_res_resource_size_value_iterator_t i) 253 { 254 xcb_generic_iterator_t ret; 255 while(i.rem > 0) 256 xcb_res_resource_size_value_next(&i); 257 ret.data = i.data; 258 ret.rem = i.rem; 259 ret.index = i.index; 260 return ret; 261 } 262 263 xcb_res_query_version_cookie_t 264 xcb_res_query_version (xcb_connection_t *c, 265 uint8_t client_major, 266 uint8_t client_minor) 267 { 268 static const xcb_protocol_request_t xcb_req = { 269 .count = 2, 270 .ext = &xcb_res_id, 271 .opcode = XCB_RES_QUERY_VERSION, 272 .isvoid = 0 273 }; 274 275 struct iovec xcb_parts[4]; 276 xcb_res_query_version_cookie_t xcb_ret; 277 xcb_res_query_version_request_t xcb_out; 278 279 xcb_out.client_major = client_major; 280 xcb_out.client_minor = client_minor; 281 282 xcb_parts[2].iov_base = (char *) &xcb_out; 283 xcb_parts[2].iov_len = sizeof(xcb_out); 284 xcb_parts[3].iov_base = 0; 285 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 286 287 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 288 return xcb_ret; 289 } 290 291 xcb_res_query_version_cookie_t 292 xcb_res_query_version_unchecked (xcb_connection_t *c, 293 uint8_t client_major, 294 uint8_t client_minor) 295 { 296 static const xcb_protocol_request_t xcb_req = { 297 .count = 2, 298 .ext = &xcb_res_id, 299 .opcode = XCB_RES_QUERY_VERSION, 300 .isvoid = 0 301 }; 302 303 struct iovec xcb_parts[4]; 304 xcb_res_query_version_cookie_t xcb_ret; 305 xcb_res_query_version_request_t xcb_out; 306 307 xcb_out.client_major = client_major; 308 xcb_out.client_minor = client_minor; 309 310 xcb_parts[2].iov_base = (char *) &xcb_out; 311 xcb_parts[2].iov_len = sizeof(xcb_out); 312 xcb_parts[3].iov_base = 0; 313 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 314 315 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 316 return xcb_ret; 317 } 318 319 xcb_res_query_version_reply_t * 320 xcb_res_query_version_reply (xcb_connection_t *c, 321 xcb_res_query_version_cookie_t cookie /**< */, 322 xcb_generic_error_t **e) 323 { 324 return (xcb_res_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 325 } 326 327 int 328 xcb_res_query_clients_sizeof (const void *_buffer) 329 { 330 char *xcb_tmp = (char *)_buffer; 331 const xcb_res_query_clients_reply_t *_aux = (xcb_res_query_clients_reply_t *)_buffer; 332 unsigned int xcb_buffer_len = 0; 333 unsigned int xcb_block_len = 0; 334 unsigned int xcb_pad = 0; 335 unsigned int xcb_align_to = 0; 336 337 338 xcb_block_len += sizeof(xcb_res_query_clients_reply_t); 339 xcb_tmp += xcb_block_len; 340 xcb_buffer_len += xcb_block_len; 341 xcb_block_len = 0; 342 /* clients */ 343 xcb_block_len += _aux->num_clients * sizeof(xcb_res_client_t); 344 xcb_tmp += xcb_block_len; 345 xcb_align_to = ALIGNOF(xcb_res_client_t); 346 /* insert padding */ 347 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 348 xcb_buffer_len += xcb_block_len + xcb_pad; 349 if (0 != xcb_pad) { 350 xcb_tmp += xcb_pad; 351 xcb_pad = 0; 352 } 353 xcb_block_len = 0; 354 355 return xcb_buffer_len; 356 } 357 358 xcb_res_query_clients_cookie_t 359 xcb_res_query_clients (xcb_connection_t *c) 360 { 361 static const xcb_protocol_request_t xcb_req = { 362 .count = 2, 363 .ext = &xcb_res_id, 364 .opcode = XCB_RES_QUERY_CLIENTS, 365 .isvoid = 0 366 }; 367 368 struct iovec xcb_parts[4]; 369 xcb_res_query_clients_cookie_t xcb_ret; 370 xcb_res_query_clients_request_t xcb_out; 371 372 373 xcb_parts[2].iov_base = (char *) &xcb_out; 374 xcb_parts[2].iov_len = sizeof(xcb_out); 375 xcb_parts[3].iov_base = 0; 376 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 377 378 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 379 return xcb_ret; 380 } 381 382 xcb_res_query_clients_cookie_t 383 xcb_res_query_clients_unchecked (xcb_connection_t *c) 384 { 385 static const xcb_protocol_request_t xcb_req = { 386 .count = 2, 387 .ext = &xcb_res_id, 388 .opcode = XCB_RES_QUERY_CLIENTS, 389 .isvoid = 0 390 }; 391 392 struct iovec xcb_parts[4]; 393 xcb_res_query_clients_cookie_t xcb_ret; 394 xcb_res_query_clients_request_t xcb_out; 395 396 397 xcb_parts[2].iov_base = (char *) &xcb_out; 398 xcb_parts[2].iov_len = sizeof(xcb_out); 399 xcb_parts[3].iov_base = 0; 400 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 401 402 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 403 return xcb_ret; 404 } 405 406 xcb_res_client_t * 407 xcb_res_query_clients_clients (const xcb_res_query_clients_reply_t *R) 408 { 409 return (xcb_res_client_t *) (R + 1); 410 } 411 412 int 413 xcb_res_query_clients_clients_length (const xcb_res_query_clients_reply_t *R) 414 { 415 return R->num_clients; 416 } 417 418 xcb_res_client_iterator_t 419 xcb_res_query_clients_clients_iterator (const xcb_res_query_clients_reply_t *R) 420 { 421 xcb_res_client_iterator_t i; 422 i.data = (xcb_res_client_t *) (R + 1); 423 i.rem = R->num_clients; 424 i.index = (char *) i.data - (char *) R; 425 return i; 426 } 427 428 xcb_res_query_clients_reply_t * 429 xcb_res_query_clients_reply (xcb_connection_t *c, 430 xcb_res_query_clients_cookie_t cookie /**< */, 431 xcb_generic_error_t **e) 432 { 433 return (xcb_res_query_clients_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 434 } 435 436 int 437 xcb_res_query_client_resources_sizeof (const void *_buffer) 438 { 439 char *xcb_tmp = (char *)_buffer; 440 const xcb_res_query_client_resources_reply_t *_aux = (xcb_res_query_client_resources_reply_t *)_buffer; 441 unsigned int xcb_buffer_len = 0; 442 unsigned int xcb_block_len = 0; 443 unsigned int xcb_pad = 0; 444 unsigned int xcb_align_to = 0; 445 446 447 xcb_block_len += sizeof(xcb_res_query_client_resources_reply_t); 448 xcb_tmp += xcb_block_len; 449 xcb_buffer_len += xcb_block_len; 450 xcb_block_len = 0; 451 /* types */ 452 xcb_block_len += _aux->num_types * sizeof(xcb_res_type_t); 453 xcb_tmp += xcb_block_len; 454 xcb_align_to = ALIGNOF(xcb_res_type_t); 455 /* insert padding */ 456 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 457 xcb_buffer_len += xcb_block_len + xcb_pad; 458 if (0 != xcb_pad) { 459 xcb_tmp += xcb_pad; 460 xcb_pad = 0; 461 } 462 xcb_block_len = 0; 463 464 return xcb_buffer_len; 465 } 466 467 xcb_res_query_client_resources_cookie_t 468 xcb_res_query_client_resources (xcb_connection_t *c, 469 uint32_t xid) 470 { 471 static const xcb_protocol_request_t xcb_req = { 472 .count = 2, 473 .ext = &xcb_res_id, 474 .opcode = XCB_RES_QUERY_CLIENT_RESOURCES, 475 .isvoid = 0 476 }; 477 478 struct iovec xcb_parts[4]; 479 xcb_res_query_client_resources_cookie_t xcb_ret; 480 xcb_res_query_client_resources_request_t xcb_out; 481 482 xcb_out.xid = xid; 483 484 xcb_parts[2].iov_base = (char *) &xcb_out; 485 xcb_parts[2].iov_len = sizeof(xcb_out); 486 xcb_parts[3].iov_base = 0; 487 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 488 489 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 490 return xcb_ret; 491 } 492 493 xcb_res_query_client_resources_cookie_t 494 xcb_res_query_client_resources_unchecked (xcb_connection_t *c, 495 uint32_t xid) 496 { 497 static const xcb_protocol_request_t xcb_req = { 498 .count = 2, 499 .ext = &xcb_res_id, 500 .opcode = XCB_RES_QUERY_CLIENT_RESOURCES, 501 .isvoid = 0 502 }; 503 504 struct iovec xcb_parts[4]; 505 xcb_res_query_client_resources_cookie_t xcb_ret; 506 xcb_res_query_client_resources_request_t xcb_out; 507 508 xcb_out.xid = xid; 509 510 xcb_parts[2].iov_base = (char *) &xcb_out; 511 xcb_parts[2].iov_len = sizeof(xcb_out); 512 xcb_parts[3].iov_base = 0; 513 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 514 515 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 516 return xcb_ret; 517 } 518 519 xcb_res_type_t * 520 xcb_res_query_client_resources_types (const xcb_res_query_client_resources_reply_t *R) 521 { 522 return (xcb_res_type_t *) (R + 1); 523 } 524 525 int 526 xcb_res_query_client_resources_types_length (const xcb_res_query_client_resources_reply_t *R) 527 { 528 return R->num_types; 529 } 530 531 xcb_res_type_iterator_t 532 xcb_res_query_client_resources_types_iterator (const xcb_res_query_client_resources_reply_t *R) 533 { 534 xcb_res_type_iterator_t i; 535 i.data = (xcb_res_type_t *) (R + 1); 536 i.rem = R->num_types; 537 i.index = (char *) i.data - (char *) R; 538 return i; 539 } 540 541 xcb_res_query_client_resources_reply_t * 542 xcb_res_query_client_resources_reply (xcb_connection_t *c, 543 xcb_res_query_client_resources_cookie_t cookie /**< */, 544 xcb_generic_error_t **e) 545 { 546 return (xcb_res_query_client_resources_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 547 } 548 549 xcb_res_query_client_pixmap_bytes_cookie_t 550 xcb_res_query_client_pixmap_bytes (xcb_connection_t *c, 551 uint32_t xid) 552 { 553 static const xcb_protocol_request_t xcb_req = { 554 .count = 2, 555 .ext = &xcb_res_id, 556 .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, 557 .isvoid = 0 558 }; 559 560 struct iovec xcb_parts[4]; 561 xcb_res_query_client_pixmap_bytes_cookie_t xcb_ret; 562 xcb_res_query_client_pixmap_bytes_request_t xcb_out; 563 564 xcb_out.xid = xid; 565 566 xcb_parts[2].iov_base = (char *) &xcb_out; 567 xcb_parts[2].iov_len = sizeof(xcb_out); 568 xcb_parts[3].iov_base = 0; 569 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 570 571 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 572 return xcb_ret; 573 } 574 575 xcb_res_query_client_pixmap_bytes_cookie_t 576 xcb_res_query_client_pixmap_bytes_unchecked (xcb_connection_t *c, 577 uint32_t xid) 578 { 579 static const xcb_protocol_request_t xcb_req = { 580 .count = 2, 581 .ext = &xcb_res_id, 582 .opcode = XCB_RES_QUERY_CLIENT_PIXMAP_BYTES, 583 .isvoid = 0 584 }; 585 586 struct iovec xcb_parts[4]; 587 xcb_res_query_client_pixmap_bytes_cookie_t xcb_ret; 588 xcb_res_query_client_pixmap_bytes_request_t xcb_out; 589 590 xcb_out.xid = xid; 591 592 xcb_parts[2].iov_base = (char *) &xcb_out; 593 xcb_parts[2].iov_len = sizeof(xcb_out); 594 xcb_parts[3].iov_base = 0; 595 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 596 597 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 598 return xcb_ret; 599 } 600 601 xcb_res_query_client_pixmap_bytes_reply_t * 602 xcb_res_query_client_pixmap_bytes_reply (xcb_connection_t *c, 603 xcb_res_query_client_pixmap_bytes_cookie_t cookie /**< */, 604 xcb_generic_error_t **e) 605 { 606 return (xcb_res_query_client_pixmap_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 607 } 608 609 int 610 xcb_res_query_client_ids_sizeof (const void *_buffer) 611 { 612 char *xcb_tmp = (char *)_buffer; 613 const xcb_res_query_client_ids_request_t *_aux = (xcb_res_query_client_ids_request_t *)_buffer; 614 unsigned int xcb_buffer_len = 0; 615 unsigned int xcb_block_len = 0; 616 unsigned int xcb_pad = 0; 617 unsigned int xcb_align_to = 0; 618 619 620 xcb_block_len += sizeof(xcb_res_query_client_ids_request_t); 621 xcb_tmp += xcb_block_len; 622 xcb_buffer_len += xcb_block_len; 623 xcb_block_len = 0; 624 /* specs */ 625 xcb_block_len += _aux->num_specs * sizeof(xcb_res_client_id_spec_t); 626 xcb_tmp += xcb_block_len; 627 xcb_align_to = ALIGNOF(xcb_res_client_id_spec_t); 628 /* insert padding */ 629 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 630 xcb_buffer_len += xcb_block_len + xcb_pad; 631 if (0 != xcb_pad) { 632 xcb_tmp += xcb_pad; 633 xcb_pad = 0; 634 } 635 xcb_block_len = 0; 636 637 return xcb_buffer_len; 638 } 639 640 xcb_res_query_client_ids_cookie_t 641 xcb_res_query_client_ids (xcb_connection_t *c, 642 uint32_t num_specs, 643 const xcb_res_client_id_spec_t *specs) 644 { 645 static const xcb_protocol_request_t xcb_req = { 646 .count = 4, 647 .ext = &xcb_res_id, 648 .opcode = XCB_RES_QUERY_CLIENT_IDS, 649 .isvoid = 0 650 }; 651 652 struct iovec xcb_parts[6]; 653 xcb_res_query_client_ids_cookie_t xcb_ret; 654 xcb_res_query_client_ids_request_t xcb_out; 655 656 xcb_out.num_specs = num_specs; 657 658 xcb_parts[2].iov_base = (char *) &xcb_out; 659 xcb_parts[2].iov_len = sizeof(xcb_out); 660 xcb_parts[3].iov_base = 0; 661 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 662 /* xcb_res_client_id_spec_t specs */ 663 xcb_parts[4].iov_base = (char *) specs; 664 xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_client_id_spec_t); 665 xcb_parts[5].iov_base = 0; 666 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 667 668 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 669 return xcb_ret; 670 } 671 672 xcb_res_query_client_ids_cookie_t 673 xcb_res_query_client_ids_unchecked (xcb_connection_t *c, 674 uint32_t num_specs, 675 const xcb_res_client_id_spec_t *specs) 676 { 677 static const xcb_protocol_request_t xcb_req = { 678 .count = 4, 679 .ext = &xcb_res_id, 680 .opcode = XCB_RES_QUERY_CLIENT_IDS, 681 .isvoid = 0 682 }; 683 684 struct iovec xcb_parts[6]; 685 xcb_res_query_client_ids_cookie_t xcb_ret; 686 xcb_res_query_client_ids_request_t xcb_out; 687 688 xcb_out.num_specs = num_specs; 689 690 xcb_parts[2].iov_base = (char *) &xcb_out; 691 xcb_parts[2].iov_len = sizeof(xcb_out); 692 xcb_parts[3].iov_base = 0; 693 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 694 /* xcb_res_client_id_spec_t specs */ 695 xcb_parts[4].iov_base = (char *) specs; 696 xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_client_id_spec_t); 697 xcb_parts[5].iov_base = 0; 698 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 699 700 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 701 return xcb_ret; 702 } 703 704 int 705 xcb_res_query_client_ids_ids_length (const xcb_res_query_client_ids_reply_t *R) 706 { 707 return R->num_ids; 708 } 709 710 xcb_res_client_id_value_iterator_t 711 xcb_res_query_client_ids_ids_iterator (const xcb_res_query_client_ids_reply_t *R) 712 { 713 xcb_res_client_id_value_iterator_t i; 714 i.data = (xcb_res_client_id_value_t *) (R + 1); 715 i.rem = R->num_ids; 716 i.index = (char *) i.data - (char *) R; 717 return i; 718 } 719 720 xcb_res_query_client_ids_reply_t * 721 xcb_res_query_client_ids_reply (xcb_connection_t *c, 722 xcb_res_query_client_ids_cookie_t cookie /**< */, 723 xcb_generic_error_t **e) 724 { 725 return (xcb_res_query_client_ids_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 726 } 727 728 int 729 xcb_res_query_resource_bytes_sizeof (const void *_buffer) 730 { 731 char *xcb_tmp = (char *)_buffer; 732 const xcb_res_query_resource_bytes_request_t *_aux = (xcb_res_query_resource_bytes_request_t *)_buffer; 733 unsigned int xcb_buffer_len = 0; 734 unsigned int xcb_block_len = 0; 735 unsigned int xcb_pad = 0; 736 unsigned int xcb_align_to = 0; 737 738 739 xcb_block_len += sizeof(xcb_res_query_resource_bytes_request_t); 740 xcb_tmp += xcb_block_len; 741 xcb_buffer_len += xcb_block_len; 742 xcb_block_len = 0; 743 /* specs */ 744 xcb_block_len += _aux->num_specs * sizeof(xcb_res_resource_id_spec_t); 745 xcb_tmp += xcb_block_len; 746 xcb_align_to = ALIGNOF(xcb_res_resource_id_spec_t); 747 /* insert padding */ 748 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 749 xcb_buffer_len += xcb_block_len + xcb_pad; 750 if (0 != xcb_pad) { 751 xcb_tmp += xcb_pad; 752 xcb_pad = 0; 753 } 754 xcb_block_len = 0; 755 756 return xcb_buffer_len; 757 } 758 759 xcb_res_query_resource_bytes_cookie_t 760 xcb_res_query_resource_bytes (xcb_connection_t *c, 761 uint32_t client, 762 uint32_t num_specs, 763 const xcb_res_resource_id_spec_t *specs) 764 { 765 static const xcb_protocol_request_t xcb_req = { 766 .count = 4, 767 .ext = &xcb_res_id, 768 .opcode = XCB_RES_QUERY_RESOURCE_BYTES, 769 .isvoid = 0 770 }; 771 772 struct iovec xcb_parts[6]; 773 xcb_res_query_resource_bytes_cookie_t xcb_ret; 774 xcb_res_query_resource_bytes_request_t xcb_out; 775 776 xcb_out.client = client; 777 xcb_out.num_specs = num_specs; 778 779 xcb_parts[2].iov_base = (char *) &xcb_out; 780 xcb_parts[2].iov_len = sizeof(xcb_out); 781 xcb_parts[3].iov_base = 0; 782 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 783 /* xcb_res_resource_id_spec_t specs */ 784 xcb_parts[4].iov_base = (char *) specs; 785 xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_resource_id_spec_t); 786 xcb_parts[5].iov_base = 0; 787 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 788 789 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 790 return xcb_ret; 791 } 792 793 xcb_res_query_resource_bytes_cookie_t 794 xcb_res_query_resource_bytes_unchecked (xcb_connection_t *c, 795 uint32_t client, 796 uint32_t num_specs, 797 const xcb_res_resource_id_spec_t *specs) 798 { 799 static const xcb_protocol_request_t xcb_req = { 800 .count = 4, 801 .ext = &xcb_res_id, 802 .opcode = XCB_RES_QUERY_RESOURCE_BYTES, 803 .isvoid = 0 804 }; 805 806 struct iovec xcb_parts[6]; 807 xcb_res_query_resource_bytes_cookie_t xcb_ret; 808 xcb_res_query_resource_bytes_request_t xcb_out; 809 810 xcb_out.client = client; 811 xcb_out.num_specs = num_specs; 812 813 xcb_parts[2].iov_base = (char *) &xcb_out; 814 xcb_parts[2].iov_len = sizeof(xcb_out); 815 xcb_parts[3].iov_base = 0; 816 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 817 /* xcb_res_resource_id_spec_t specs */ 818 xcb_parts[4].iov_base = (char *) specs; 819 xcb_parts[4].iov_len = num_specs * sizeof(xcb_res_resource_id_spec_t); 820 xcb_parts[5].iov_base = 0; 821 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 822 823 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 824 return xcb_ret; 825 } 826 827 int 828 xcb_res_query_resource_bytes_sizes_length (const xcb_res_query_resource_bytes_reply_t *R) 829 { 830 return R->num_sizes; 831 } 832 833 xcb_res_resource_size_value_iterator_t 834 xcb_res_query_resource_bytes_sizes_iterator (const xcb_res_query_resource_bytes_reply_t *R) 835 { 836 xcb_res_resource_size_value_iterator_t i; 837 i.data = (xcb_res_resource_size_value_t *) (R + 1); 838 i.rem = R->num_sizes; 839 i.index = (char *) i.data - (char *) R; 840 return i; 841 } 842 843 xcb_res_query_resource_bytes_reply_t * 844 xcb_res_query_resource_bytes_reply (xcb_connection_t *c, 845 xcb_res_query_resource_bytes_cookie_t cookie /**< */, 846 xcb_generic_error_t **e) 847 { 848 return (xcb_res_query_resource_bytes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 849 } 850 851