1 /* 2 * This file generated automatically from xprint.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 "xprint.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_x_print_id = { "XpExtension", 0 }; 20 21 22 /***************************************************************************** 23 ** 24 ** void xcb_x_print_string8_next 25 ** 26 ** @param xcb_x_print_string8_iterator_t *i 27 ** @returns void 28 ** 29 *****************************************************************************/ 30 31 void 32 xcb_x_print_string8_next (xcb_x_print_string8_iterator_t *i /**< */) 33 { 34 --i->rem; 35 ++i->data; 36 i->index += sizeof(xcb_x_print_string8_t); 37 } 38 39 40 /***************************************************************************** 41 ** 42 ** xcb_generic_iterator_t xcb_x_print_string8_end 43 ** 44 ** @param xcb_x_print_string8_iterator_t i 45 ** @returns xcb_generic_iterator_t 46 ** 47 *****************************************************************************/ 48 49 xcb_generic_iterator_t 50 xcb_x_print_string8_end (xcb_x_print_string8_iterator_t i /**< */) 51 { 52 xcb_generic_iterator_t ret; 53 ret.data = i.data + i.rem; 54 ret.index = i.index + ((char *) ret.data - (char *) i.data); 55 ret.rem = 0; 56 return ret; 57 } 58 59 int 60 xcb_x_print_printer_serialize (void **_buffer /**< */, 61 const xcb_x_print_printer_t *_aux /**< */, 62 const xcb_x_print_string8_t *name /**< */, 63 const xcb_x_print_string8_t *description /**< */) 64 { 65 char *xcb_out = *_buffer; 66 unsigned int xcb_buffer_len = 0; 67 unsigned int xcb_align_to; 68 69 unsigned int xcb_pad = 0; 70 char xcb_pad0[3] = {0, 0, 0}; 71 struct iovec xcb_parts[5]; 72 unsigned int xcb_parts_idx = 0; 73 unsigned int xcb_block_len = 0; 74 unsigned int i; 75 char *xcb_tmp; 76 77 /* xcb_x_print_printer_t.nameLen */ 78 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->nameLen; 79 xcb_block_len += sizeof(uint32_t); 80 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 81 xcb_parts_idx++; 82 xcb_align_to = ALIGNOF(uint32_t); 83 /* name */ 84 xcb_parts[xcb_parts_idx].iov_base = (char *) name; 85 xcb_block_len += _aux->nameLen * sizeof(xcb_x_print_string8_t); 86 xcb_parts[xcb_parts_idx].iov_len = _aux->nameLen * sizeof(xcb_x_print_string8_t); 87 xcb_parts_idx++; 88 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 89 /* xcb_x_print_printer_t.descLen */ 90 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->descLen; 91 xcb_block_len += sizeof(uint32_t); 92 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 93 xcb_parts_idx++; 94 xcb_align_to = ALIGNOF(uint32_t); 95 /* description */ 96 xcb_parts[xcb_parts_idx].iov_base = (char *) description; 97 xcb_block_len += _aux->descLen * sizeof(xcb_x_print_string8_t); 98 xcb_parts[xcb_parts_idx].iov_len = _aux->descLen * sizeof(xcb_x_print_string8_t); 99 xcb_parts_idx++; 100 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 101 /* insert padding */ 102 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 103 xcb_buffer_len += xcb_block_len + xcb_pad; 104 if (0 != xcb_pad) { 105 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 106 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 107 xcb_parts_idx++; 108 xcb_pad = 0; 109 } 110 xcb_block_len = 0; 111 112 if (NULL == xcb_out) { 113 /* allocate memory */ 114 xcb_out = malloc(xcb_buffer_len); 115 *_buffer = xcb_out; 116 } 117 118 xcb_tmp = xcb_out; 119 for(i=0; i<xcb_parts_idx; i++) { 120 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 121 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 122 if (0 != xcb_parts[i].iov_len) 123 xcb_tmp += xcb_parts[i].iov_len; 124 } 125 126 return xcb_buffer_len; 127 } 128 129 int 130 xcb_x_print_printer_unserialize (const void *_buffer /**< */, 131 xcb_x_print_printer_t **_aux /**< */) 132 { 133 char *xcb_tmp = (char *)_buffer; 134 xcb_x_print_printer_t xcb_out; 135 unsigned int xcb_buffer_len = 0; 136 unsigned int xcb_block_len = 0; 137 unsigned int xcb_pad = 0; 138 unsigned int xcb_align_to; 139 140 xcb_x_print_string8_t *name; 141 int name_len; 142 xcb_x_print_string8_t *description; 143 int description_len; 144 145 /* xcb_x_print_printer_t.nameLen */ 146 xcb_out.nameLen = *(uint32_t *)xcb_tmp; 147 xcb_block_len += sizeof(uint32_t); 148 xcb_tmp += sizeof(uint32_t); 149 xcb_align_to = ALIGNOF(uint32_t); 150 /* name */ 151 name = (xcb_x_print_string8_t *)xcb_tmp; 152 name_len = xcb_out.nameLen * sizeof(xcb_x_print_string8_t); 153 xcb_block_len += name_len; 154 xcb_tmp += name_len; 155 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 156 /* xcb_x_print_printer_t.descLen */ 157 xcb_out.descLen = *(uint32_t *)xcb_tmp; 158 xcb_block_len += sizeof(uint32_t); 159 xcb_tmp += sizeof(uint32_t); 160 xcb_align_to = ALIGNOF(uint32_t); 161 /* description */ 162 description = (xcb_x_print_string8_t *)xcb_tmp; 163 description_len = xcb_out.descLen * sizeof(xcb_x_print_string8_t); 164 xcb_block_len += description_len; 165 xcb_tmp += description_len; 166 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 167 /* insert padding */ 168 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 169 xcb_buffer_len += xcb_block_len + xcb_pad; 170 if (0 != xcb_pad) { 171 xcb_tmp += xcb_pad; 172 xcb_pad = 0; 173 } 174 xcb_block_len = 0; 175 176 if (NULL == _aux) 177 return xcb_buffer_len; 178 179 if (NULL == *_aux) { 180 /* allocate memory */ 181 *_aux = malloc(xcb_buffer_len); 182 } 183 184 xcb_tmp = ((char *)*_aux)+xcb_buffer_len; 185 xcb_tmp -= description_len; 186 memmove(xcb_tmp, description, description_len); 187 xcb_tmp -= name_len; 188 memmove(xcb_tmp, name, name_len); 189 **_aux = xcb_out; 190 191 return xcb_buffer_len; 192 } 193 194 int 195 xcb_x_print_printer_sizeof (const void *_buffer /**< */) 196 { 197 return xcb_x_print_printer_unserialize(_buffer, NULL); 198 } 199 200 201 /***************************************************************************** 202 ** 203 ** xcb_x_print_string8_t * xcb_x_print_printer_name 204 ** 205 ** @param const xcb_x_print_printer_t *R 206 ** @returns xcb_x_print_string8_t * 207 ** 208 *****************************************************************************/ 209 210 xcb_x_print_string8_t * 211 xcb_x_print_printer_name (const xcb_x_print_printer_t *R /**< */) 212 { 213 return (xcb_x_print_string8_t *) (R + 1); 214 } 215 216 217 /***************************************************************************** 218 ** 219 ** int xcb_x_print_printer_name_length 220 ** 221 ** @param const xcb_x_print_printer_t *R 222 ** @returns int 223 ** 224 *****************************************************************************/ 225 226 int 227 xcb_x_print_printer_name_length (const xcb_x_print_printer_t *R /**< */) 228 { 229 return R->nameLen; 230 } 231 232 233 /***************************************************************************** 234 ** 235 ** xcb_generic_iterator_t xcb_x_print_printer_name_end 236 ** 237 ** @param const xcb_x_print_printer_t *R 238 ** @returns xcb_generic_iterator_t 239 ** 240 *****************************************************************************/ 241 242 xcb_generic_iterator_t 243 xcb_x_print_printer_name_end (const xcb_x_print_printer_t *R /**< */) 244 { 245 xcb_generic_iterator_t i; 246 i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->nameLen); 247 i.rem = 0; 248 i.index = (char *) i.data - (char *) R; 249 return i; 250 } 251 252 253 /***************************************************************************** 254 ** 255 ** xcb_x_print_string8_t * xcb_x_print_printer_description 256 ** 257 ** @param const xcb_x_print_printer_t *R 258 ** @returns xcb_x_print_string8_t * 259 ** 260 *****************************************************************************/ 261 262 xcb_x_print_string8_t * 263 xcb_x_print_printer_description (const xcb_x_print_printer_t *R /**< */) 264 { 265 xcb_generic_iterator_t prev = xcb_x_print_printer_name_end(R); 266 return (xcb_x_print_string8_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 4); 267 } 268 269 270 /***************************************************************************** 271 ** 272 ** int xcb_x_print_printer_description_length 273 ** 274 ** @param const xcb_x_print_printer_t *R 275 ** @returns int 276 ** 277 *****************************************************************************/ 278 279 int 280 xcb_x_print_printer_description_length (const xcb_x_print_printer_t *R /**< */) 281 { 282 return R->descLen; 283 } 284 285 286 /***************************************************************************** 287 ** 288 ** xcb_generic_iterator_t xcb_x_print_printer_description_end 289 ** 290 ** @param const xcb_x_print_printer_t *R 291 ** @returns xcb_generic_iterator_t 292 ** 293 *****************************************************************************/ 294 295 xcb_generic_iterator_t 296 xcb_x_print_printer_description_end (const xcb_x_print_printer_t *R /**< */) 297 { 298 xcb_generic_iterator_t i; 299 xcb_generic_iterator_t child = xcb_x_print_printer_name_end(R); 300 i.data = ((xcb_x_print_string8_t *) child.data) + (R->descLen); 301 i.rem = 0; 302 i.index = (char *) i.data - (char *) R; 303 return i; 304 } 305 306 307 /***************************************************************************** 308 ** 309 ** void xcb_x_print_printer_next 310 ** 311 ** @param xcb_x_print_printer_iterator_t *i 312 ** @returns void 313 ** 314 *****************************************************************************/ 315 316 void 317 xcb_x_print_printer_next (xcb_x_print_printer_iterator_t *i /**< */) 318 { 319 xcb_x_print_printer_t *R = i->data; 320 xcb_generic_iterator_t child; 321 child.data = (xcb_x_print_printer_t *)(((char *)R) + xcb_x_print_printer_sizeof(R)); 322 i->index = (char *) child.data - (char *) i->data; 323 --i->rem; 324 i->data = (xcb_x_print_printer_t *) child.data; 325 } 326 327 328 /***************************************************************************** 329 ** 330 ** xcb_generic_iterator_t xcb_x_print_printer_end 331 ** 332 ** @param xcb_x_print_printer_iterator_t i 333 ** @returns xcb_generic_iterator_t 334 ** 335 *****************************************************************************/ 336 337 xcb_generic_iterator_t 338 xcb_x_print_printer_end (xcb_x_print_printer_iterator_t i /**< */) 339 { 340 xcb_generic_iterator_t ret; 341 while(i.rem > 0) 342 xcb_x_print_printer_next(&i); 343 ret.data = i.data; 344 ret.rem = i.rem; 345 ret.index = i.index; 346 return ret; 347 } 348 349 350 /***************************************************************************** 351 ** 352 ** void xcb_x_print_pcontext_next 353 ** 354 ** @param xcb_x_print_pcontext_iterator_t *i 355 ** @returns void 356 ** 357 *****************************************************************************/ 358 359 void 360 xcb_x_print_pcontext_next (xcb_x_print_pcontext_iterator_t *i /**< */) 361 { 362 --i->rem; 363 ++i->data; 364 i->index += sizeof(xcb_x_print_pcontext_t); 365 } 366 367 368 /***************************************************************************** 369 ** 370 ** xcb_generic_iterator_t xcb_x_print_pcontext_end 371 ** 372 ** @param xcb_x_print_pcontext_iterator_t i 373 ** @returns xcb_generic_iterator_t 374 ** 375 *****************************************************************************/ 376 377 xcb_generic_iterator_t 378 xcb_x_print_pcontext_end (xcb_x_print_pcontext_iterator_t i /**< */) 379 { 380 xcb_generic_iterator_t ret; 381 ret.data = i.data + i.rem; 382 ret.index = i.index + ((char *) ret.data - (char *) i.data); 383 ret.rem = 0; 384 return ret; 385 } 386 387 388 /***************************************************************************** 389 ** 390 ** xcb_x_print_print_query_version_cookie_t xcb_x_print_print_query_version 391 ** 392 ** @param xcb_connection_t *c 393 ** @returns xcb_x_print_print_query_version_cookie_t 394 ** 395 *****************************************************************************/ 396 397 xcb_x_print_print_query_version_cookie_t 398 xcb_x_print_print_query_version (xcb_connection_t *c /**< */) 399 { 400 static const xcb_protocol_request_t xcb_req = { 401 /* count */ 2, 402 /* ext */ &xcb_x_print_id, 403 /* opcode */ XCB_X_PRINT_PRINT_QUERY_VERSION, 404 /* isvoid */ 0 405 }; 406 407 struct iovec xcb_parts[4]; 408 xcb_x_print_print_query_version_cookie_t xcb_ret; 409 xcb_x_print_print_query_version_request_t xcb_out; 410 411 412 xcb_parts[2].iov_base = (char *) &xcb_out; 413 xcb_parts[2].iov_len = sizeof(xcb_out); 414 xcb_parts[3].iov_base = 0; 415 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 416 417 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 418 return xcb_ret; 419 } 420 421 422 /***************************************************************************** 423 ** 424 ** xcb_x_print_print_query_version_cookie_t xcb_x_print_print_query_version_unchecked 425 ** 426 ** @param xcb_connection_t *c 427 ** @returns xcb_x_print_print_query_version_cookie_t 428 ** 429 *****************************************************************************/ 430 431 xcb_x_print_print_query_version_cookie_t 432 xcb_x_print_print_query_version_unchecked (xcb_connection_t *c /**< */) 433 { 434 static const xcb_protocol_request_t xcb_req = { 435 /* count */ 2, 436 /* ext */ &xcb_x_print_id, 437 /* opcode */ XCB_X_PRINT_PRINT_QUERY_VERSION, 438 /* isvoid */ 0 439 }; 440 441 struct iovec xcb_parts[4]; 442 xcb_x_print_print_query_version_cookie_t xcb_ret; 443 xcb_x_print_print_query_version_request_t xcb_out; 444 445 446 xcb_parts[2].iov_base = (char *) &xcb_out; 447 xcb_parts[2].iov_len = sizeof(xcb_out); 448 xcb_parts[3].iov_base = 0; 449 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 450 451 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 452 return xcb_ret; 453 } 454 455 456 /***************************************************************************** 457 ** 458 ** xcb_x_print_print_query_version_reply_t * xcb_x_print_print_query_version_reply 459 ** 460 ** @param xcb_connection_t *c 461 ** @param xcb_x_print_print_query_version_cookie_t cookie 462 ** @param xcb_generic_error_t **e 463 ** @returns xcb_x_print_print_query_version_reply_t * 464 ** 465 *****************************************************************************/ 466 467 xcb_x_print_print_query_version_reply_t * 468 xcb_x_print_print_query_version_reply (xcb_connection_t *c /**< */, 469 xcb_x_print_print_query_version_cookie_t cookie /**< */, 470 xcb_generic_error_t **e /**< */) 471 { 472 return (xcb_x_print_print_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 473 } 474 475 int 476 xcb_x_print_print_get_printer_list_sizeof (const void *_buffer /**< */) 477 { 478 char *xcb_tmp = (char *)_buffer; 479 const xcb_x_print_print_get_printer_list_request_t *_aux = (xcb_x_print_print_get_printer_list_request_t *)_buffer; 480 unsigned int xcb_buffer_len = 0; 481 unsigned int xcb_block_len = 0; 482 unsigned int xcb_pad = 0; 483 unsigned int xcb_align_to; 484 485 486 xcb_block_len += sizeof(xcb_x_print_print_get_printer_list_request_t); 487 xcb_tmp += xcb_block_len; 488 /* printer_name */ 489 xcb_block_len += _aux->printerNameLen * sizeof(xcb_x_print_string8_t); 490 xcb_tmp += xcb_block_len; 491 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 492 /* insert padding */ 493 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 494 xcb_buffer_len += xcb_block_len + xcb_pad; 495 if (0 != xcb_pad) { 496 xcb_tmp += xcb_pad; 497 xcb_pad = 0; 498 } 499 xcb_block_len = 0; 500 /* locale */ 501 xcb_block_len += _aux->localeLen * sizeof(xcb_x_print_string8_t); 502 xcb_tmp += xcb_block_len; 503 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 504 /* insert padding */ 505 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 506 xcb_buffer_len += xcb_block_len + xcb_pad; 507 if (0 != xcb_pad) { 508 xcb_tmp += xcb_pad; 509 xcb_pad = 0; 510 } 511 xcb_block_len = 0; 512 513 return xcb_buffer_len; 514 } 515 516 517 /***************************************************************************** 518 ** 519 ** xcb_x_print_print_get_printer_list_cookie_t xcb_x_print_print_get_printer_list 520 ** 521 ** @param xcb_connection_t *c 522 ** @param uint32_t printerNameLen 523 ** @param uint32_t localeLen 524 ** @param const xcb_x_print_string8_t *printer_name 525 ** @param const xcb_x_print_string8_t *locale 526 ** @returns xcb_x_print_print_get_printer_list_cookie_t 527 ** 528 *****************************************************************************/ 529 530 xcb_x_print_print_get_printer_list_cookie_t 531 xcb_x_print_print_get_printer_list (xcb_connection_t *c /**< */, 532 uint32_t printerNameLen /**< */, 533 uint32_t localeLen /**< */, 534 const xcb_x_print_string8_t *printer_name /**< */, 535 const xcb_x_print_string8_t *locale /**< */) 536 { 537 static const xcb_protocol_request_t xcb_req = { 538 /* count */ 6, 539 /* ext */ &xcb_x_print_id, 540 /* opcode */ XCB_X_PRINT_PRINT_GET_PRINTER_LIST, 541 /* isvoid */ 0 542 }; 543 544 struct iovec xcb_parts[8]; 545 xcb_x_print_print_get_printer_list_cookie_t xcb_ret; 546 xcb_x_print_print_get_printer_list_request_t xcb_out; 547 548 xcb_out.printerNameLen = printerNameLen; 549 xcb_out.localeLen = localeLen; 550 551 xcb_parts[2].iov_base = (char *) &xcb_out; 552 xcb_parts[2].iov_len = sizeof(xcb_out); 553 xcb_parts[3].iov_base = 0; 554 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 555 /* xcb_x_print_string8_t printer_name */ 556 xcb_parts[4].iov_base = (char *) printer_name; 557 xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t); 558 xcb_parts[5].iov_base = 0; 559 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 560 /* xcb_x_print_string8_t locale */ 561 xcb_parts[6].iov_base = (char *) locale; 562 xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t); 563 xcb_parts[7].iov_base = 0; 564 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 565 566 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 567 return xcb_ret; 568 } 569 570 571 /***************************************************************************** 572 ** 573 ** xcb_x_print_print_get_printer_list_cookie_t xcb_x_print_print_get_printer_list_unchecked 574 ** 575 ** @param xcb_connection_t *c 576 ** @param uint32_t printerNameLen 577 ** @param uint32_t localeLen 578 ** @param const xcb_x_print_string8_t *printer_name 579 ** @param const xcb_x_print_string8_t *locale 580 ** @returns xcb_x_print_print_get_printer_list_cookie_t 581 ** 582 *****************************************************************************/ 583 584 xcb_x_print_print_get_printer_list_cookie_t 585 xcb_x_print_print_get_printer_list_unchecked (xcb_connection_t *c /**< */, 586 uint32_t printerNameLen /**< */, 587 uint32_t localeLen /**< */, 588 const xcb_x_print_string8_t *printer_name /**< */, 589 const xcb_x_print_string8_t *locale /**< */) 590 { 591 static const xcb_protocol_request_t xcb_req = { 592 /* count */ 6, 593 /* ext */ &xcb_x_print_id, 594 /* opcode */ XCB_X_PRINT_PRINT_GET_PRINTER_LIST, 595 /* isvoid */ 0 596 }; 597 598 struct iovec xcb_parts[8]; 599 xcb_x_print_print_get_printer_list_cookie_t xcb_ret; 600 xcb_x_print_print_get_printer_list_request_t xcb_out; 601 602 xcb_out.printerNameLen = printerNameLen; 603 xcb_out.localeLen = localeLen; 604 605 xcb_parts[2].iov_base = (char *) &xcb_out; 606 xcb_parts[2].iov_len = sizeof(xcb_out); 607 xcb_parts[3].iov_base = 0; 608 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 609 /* xcb_x_print_string8_t printer_name */ 610 xcb_parts[4].iov_base = (char *) printer_name; 611 xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t); 612 xcb_parts[5].iov_base = 0; 613 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 614 /* xcb_x_print_string8_t locale */ 615 xcb_parts[6].iov_base = (char *) locale; 616 xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t); 617 xcb_parts[7].iov_base = 0; 618 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 619 620 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 621 return xcb_ret; 622 } 623 624 625 /***************************************************************************** 626 ** 627 ** int xcb_x_print_print_get_printer_list_printers_length 628 ** 629 ** @param const xcb_x_print_print_get_printer_list_reply_t *R 630 ** @returns int 631 ** 632 *****************************************************************************/ 633 634 int 635 xcb_x_print_print_get_printer_list_printers_length (const xcb_x_print_print_get_printer_list_reply_t *R /**< */) 636 { 637 return R->listCount; 638 } 639 640 641 /***************************************************************************** 642 ** 643 ** xcb_x_print_printer_iterator_t xcb_x_print_print_get_printer_list_printers_iterator 644 ** 645 ** @param const xcb_x_print_print_get_printer_list_reply_t *R 646 ** @returns xcb_x_print_printer_iterator_t 647 ** 648 *****************************************************************************/ 649 650 xcb_x_print_printer_iterator_t 651 xcb_x_print_print_get_printer_list_printers_iterator (const xcb_x_print_print_get_printer_list_reply_t *R /**< */) 652 { 653 xcb_x_print_printer_iterator_t i; 654 i.data = (xcb_x_print_printer_t *) (R + 1); 655 i.rem = R->listCount; 656 i.index = (char *) i.data - (char *) R; 657 return i; 658 } 659 660 661 /***************************************************************************** 662 ** 663 ** xcb_x_print_print_get_printer_list_reply_t * xcb_x_print_print_get_printer_list_reply 664 ** 665 ** @param xcb_connection_t *c 666 ** @param xcb_x_print_print_get_printer_list_cookie_t cookie 667 ** @param xcb_generic_error_t **e 668 ** @returns xcb_x_print_print_get_printer_list_reply_t * 669 ** 670 *****************************************************************************/ 671 672 xcb_x_print_print_get_printer_list_reply_t * 673 xcb_x_print_print_get_printer_list_reply (xcb_connection_t *c /**< */, 674 xcb_x_print_print_get_printer_list_cookie_t cookie /**< */, 675 xcb_generic_error_t **e /**< */) 676 { 677 xcb_x_print_print_get_printer_list_reply_t *reply = (xcb_x_print_print_get_printer_list_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 678 int i; 679 xcb_x_print_printer_iterator_t printers_iter = xcb_x_print_print_get_printer_list_printers_iterator(reply); 680 int printers_len = xcb_x_print_print_get_printer_list_printers_length(reply); 681 xcb_x_print_printer_t *printers_data; 682 /* special cases: transform parts of the reply to match XCB data structures */ 683 for(i=0; i<printers_len; i++) { 684 printers_data = printers_iter.data; 685 xcb_x_print_printer_unserialize((const void *)printers_data, &printers_data); 686 xcb_x_print_printer_next(&printers_iter); 687 } 688 return reply; 689 } 690 691 692 /***************************************************************************** 693 ** 694 ** xcb_void_cookie_t xcb_x_print_print_rehash_printer_list_checked 695 ** 696 ** @param xcb_connection_t *c 697 ** @returns xcb_void_cookie_t 698 ** 699 *****************************************************************************/ 700 701 xcb_void_cookie_t 702 xcb_x_print_print_rehash_printer_list_checked (xcb_connection_t *c /**< */) 703 { 704 static const xcb_protocol_request_t xcb_req = { 705 /* count */ 2, 706 /* ext */ &xcb_x_print_id, 707 /* opcode */ XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, 708 /* isvoid */ 1 709 }; 710 711 struct iovec xcb_parts[4]; 712 xcb_void_cookie_t xcb_ret; 713 xcb_x_print_print_rehash_printer_list_request_t xcb_out; 714 715 716 xcb_parts[2].iov_base = (char *) &xcb_out; 717 xcb_parts[2].iov_len = sizeof(xcb_out); 718 xcb_parts[3].iov_base = 0; 719 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 720 721 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 722 return xcb_ret; 723 } 724 725 726 /***************************************************************************** 727 ** 728 ** xcb_void_cookie_t xcb_x_print_print_rehash_printer_list 729 ** 730 ** @param xcb_connection_t *c 731 ** @returns xcb_void_cookie_t 732 ** 733 *****************************************************************************/ 734 735 xcb_void_cookie_t 736 xcb_x_print_print_rehash_printer_list (xcb_connection_t *c /**< */) 737 { 738 static const xcb_protocol_request_t xcb_req = { 739 /* count */ 2, 740 /* ext */ &xcb_x_print_id, 741 /* opcode */ XCB_X_PRINT_PRINT_REHASH_PRINTER_LIST, 742 /* isvoid */ 1 743 }; 744 745 struct iovec xcb_parts[4]; 746 xcb_void_cookie_t xcb_ret; 747 xcb_x_print_print_rehash_printer_list_request_t xcb_out; 748 749 750 xcb_parts[2].iov_base = (char *) &xcb_out; 751 xcb_parts[2].iov_len = sizeof(xcb_out); 752 xcb_parts[3].iov_base = 0; 753 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 754 755 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 756 return xcb_ret; 757 } 758 759 int 760 xcb_x_print_create_context_sizeof (const void *_buffer /**< */) 761 { 762 char *xcb_tmp = (char *)_buffer; 763 const xcb_x_print_create_context_request_t *_aux = (xcb_x_print_create_context_request_t *)_buffer; 764 unsigned int xcb_buffer_len = 0; 765 unsigned int xcb_block_len = 0; 766 unsigned int xcb_pad = 0; 767 unsigned int xcb_align_to; 768 769 770 xcb_block_len += sizeof(xcb_x_print_create_context_request_t); 771 xcb_tmp += xcb_block_len; 772 /* printerName */ 773 xcb_block_len += _aux->printerNameLen * sizeof(xcb_x_print_string8_t); 774 xcb_tmp += xcb_block_len; 775 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 776 /* insert padding */ 777 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 778 xcb_buffer_len += xcb_block_len + xcb_pad; 779 if (0 != xcb_pad) { 780 xcb_tmp += xcb_pad; 781 xcb_pad = 0; 782 } 783 xcb_block_len = 0; 784 /* locale */ 785 xcb_block_len += _aux->localeLen * sizeof(xcb_x_print_string8_t); 786 xcb_tmp += xcb_block_len; 787 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 788 /* insert padding */ 789 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 790 xcb_buffer_len += xcb_block_len + xcb_pad; 791 if (0 != xcb_pad) { 792 xcb_tmp += xcb_pad; 793 xcb_pad = 0; 794 } 795 xcb_block_len = 0; 796 797 return xcb_buffer_len; 798 } 799 800 801 /***************************************************************************** 802 ** 803 ** xcb_void_cookie_t xcb_x_print_create_context_checked 804 ** 805 ** @param xcb_connection_t *c 806 ** @param uint32_t context_id 807 ** @param uint32_t printerNameLen 808 ** @param uint32_t localeLen 809 ** @param const xcb_x_print_string8_t *printerName 810 ** @param const xcb_x_print_string8_t *locale 811 ** @returns xcb_void_cookie_t 812 ** 813 *****************************************************************************/ 814 815 xcb_void_cookie_t 816 xcb_x_print_create_context_checked (xcb_connection_t *c /**< */, 817 uint32_t context_id /**< */, 818 uint32_t printerNameLen /**< */, 819 uint32_t localeLen /**< */, 820 const xcb_x_print_string8_t *printerName /**< */, 821 const xcb_x_print_string8_t *locale /**< */) 822 { 823 static const xcb_protocol_request_t xcb_req = { 824 /* count */ 6, 825 /* ext */ &xcb_x_print_id, 826 /* opcode */ XCB_X_PRINT_CREATE_CONTEXT, 827 /* isvoid */ 1 828 }; 829 830 struct iovec xcb_parts[8]; 831 xcb_void_cookie_t xcb_ret; 832 xcb_x_print_create_context_request_t xcb_out; 833 834 xcb_out.context_id = context_id; 835 xcb_out.printerNameLen = printerNameLen; 836 xcb_out.localeLen = localeLen; 837 838 xcb_parts[2].iov_base = (char *) &xcb_out; 839 xcb_parts[2].iov_len = sizeof(xcb_out); 840 xcb_parts[3].iov_base = 0; 841 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 842 /* xcb_x_print_string8_t printerName */ 843 xcb_parts[4].iov_base = (char *) printerName; 844 xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t); 845 xcb_parts[5].iov_base = 0; 846 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 847 /* xcb_x_print_string8_t locale */ 848 xcb_parts[6].iov_base = (char *) locale; 849 xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t); 850 xcb_parts[7].iov_base = 0; 851 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 852 853 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 854 return xcb_ret; 855 } 856 857 858 /***************************************************************************** 859 ** 860 ** xcb_void_cookie_t xcb_x_print_create_context 861 ** 862 ** @param xcb_connection_t *c 863 ** @param uint32_t context_id 864 ** @param uint32_t printerNameLen 865 ** @param uint32_t localeLen 866 ** @param const xcb_x_print_string8_t *printerName 867 ** @param const xcb_x_print_string8_t *locale 868 ** @returns xcb_void_cookie_t 869 ** 870 *****************************************************************************/ 871 872 xcb_void_cookie_t 873 xcb_x_print_create_context (xcb_connection_t *c /**< */, 874 uint32_t context_id /**< */, 875 uint32_t printerNameLen /**< */, 876 uint32_t localeLen /**< */, 877 const xcb_x_print_string8_t *printerName /**< */, 878 const xcb_x_print_string8_t *locale /**< */) 879 { 880 static const xcb_protocol_request_t xcb_req = { 881 /* count */ 6, 882 /* ext */ &xcb_x_print_id, 883 /* opcode */ XCB_X_PRINT_CREATE_CONTEXT, 884 /* isvoid */ 1 885 }; 886 887 struct iovec xcb_parts[8]; 888 xcb_void_cookie_t xcb_ret; 889 xcb_x_print_create_context_request_t xcb_out; 890 891 xcb_out.context_id = context_id; 892 xcb_out.printerNameLen = printerNameLen; 893 xcb_out.localeLen = localeLen; 894 895 xcb_parts[2].iov_base = (char *) &xcb_out; 896 xcb_parts[2].iov_len = sizeof(xcb_out); 897 xcb_parts[3].iov_base = 0; 898 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 899 /* xcb_x_print_string8_t printerName */ 900 xcb_parts[4].iov_base = (char *) printerName; 901 xcb_parts[4].iov_len = printerNameLen * sizeof(xcb_x_print_string8_t); 902 xcb_parts[5].iov_base = 0; 903 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 904 /* xcb_x_print_string8_t locale */ 905 xcb_parts[6].iov_base = (char *) locale; 906 xcb_parts[6].iov_len = localeLen * sizeof(xcb_x_print_string8_t); 907 xcb_parts[7].iov_base = 0; 908 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 909 910 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 911 return xcb_ret; 912 } 913 914 915 /***************************************************************************** 916 ** 917 ** xcb_void_cookie_t xcb_x_print_print_set_context_checked 918 ** 919 ** @param xcb_connection_t *c 920 ** @param uint32_t context 921 ** @returns xcb_void_cookie_t 922 ** 923 *****************************************************************************/ 924 925 xcb_void_cookie_t 926 xcb_x_print_print_set_context_checked (xcb_connection_t *c /**< */, 927 uint32_t context /**< */) 928 { 929 static const xcb_protocol_request_t xcb_req = { 930 /* count */ 2, 931 /* ext */ &xcb_x_print_id, 932 /* opcode */ XCB_X_PRINT_PRINT_SET_CONTEXT, 933 /* isvoid */ 1 934 }; 935 936 struct iovec xcb_parts[4]; 937 xcb_void_cookie_t xcb_ret; 938 xcb_x_print_print_set_context_request_t xcb_out; 939 940 xcb_out.context = context; 941 942 xcb_parts[2].iov_base = (char *) &xcb_out; 943 xcb_parts[2].iov_len = sizeof(xcb_out); 944 xcb_parts[3].iov_base = 0; 945 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 946 947 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 948 return xcb_ret; 949 } 950 951 952 /***************************************************************************** 953 ** 954 ** xcb_void_cookie_t xcb_x_print_print_set_context 955 ** 956 ** @param xcb_connection_t *c 957 ** @param uint32_t context 958 ** @returns xcb_void_cookie_t 959 ** 960 *****************************************************************************/ 961 962 xcb_void_cookie_t 963 xcb_x_print_print_set_context (xcb_connection_t *c /**< */, 964 uint32_t context /**< */) 965 { 966 static const xcb_protocol_request_t xcb_req = { 967 /* count */ 2, 968 /* ext */ &xcb_x_print_id, 969 /* opcode */ XCB_X_PRINT_PRINT_SET_CONTEXT, 970 /* isvoid */ 1 971 }; 972 973 struct iovec xcb_parts[4]; 974 xcb_void_cookie_t xcb_ret; 975 xcb_x_print_print_set_context_request_t xcb_out; 976 977 xcb_out.context = context; 978 979 xcb_parts[2].iov_base = (char *) &xcb_out; 980 xcb_parts[2].iov_len = sizeof(xcb_out); 981 xcb_parts[3].iov_base = 0; 982 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 983 984 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 985 return xcb_ret; 986 } 987 988 989 /***************************************************************************** 990 ** 991 ** xcb_x_print_print_get_context_cookie_t xcb_x_print_print_get_context 992 ** 993 ** @param xcb_connection_t *c 994 ** @returns xcb_x_print_print_get_context_cookie_t 995 ** 996 *****************************************************************************/ 997 998 xcb_x_print_print_get_context_cookie_t 999 xcb_x_print_print_get_context (xcb_connection_t *c /**< */) 1000 { 1001 static const xcb_protocol_request_t xcb_req = { 1002 /* count */ 2, 1003 /* ext */ &xcb_x_print_id, 1004 /* opcode */ XCB_X_PRINT_PRINT_GET_CONTEXT, 1005 /* isvoid */ 0 1006 }; 1007 1008 struct iovec xcb_parts[4]; 1009 xcb_x_print_print_get_context_cookie_t xcb_ret; 1010 xcb_x_print_print_get_context_request_t xcb_out; 1011 1012 1013 xcb_parts[2].iov_base = (char *) &xcb_out; 1014 xcb_parts[2].iov_len = sizeof(xcb_out); 1015 xcb_parts[3].iov_base = 0; 1016 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1017 1018 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1019 return xcb_ret; 1020 } 1021 1022 1023 /***************************************************************************** 1024 ** 1025 ** xcb_x_print_print_get_context_cookie_t xcb_x_print_print_get_context_unchecked 1026 ** 1027 ** @param xcb_connection_t *c 1028 ** @returns xcb_x_print_print_get_context_cookie_t 1029 ** 1030 *****************************************************************************/ 1031 1032 xcb_x_print_print_get_context_cookie_t 1033 xcb_x_print_print_get_context_unchecked (xcb_connection_t *c /**< */) 1034 { 1035 static const xcb_protocol_request_t xcb_req = { 1036 /* count */ 2, 1037 /* ext */ &xcb_x_print_id, 1038 /* opcode */ XCB_X_PRINT_PRINT_GET_CONTEXT, 1039 /* isvoid */ 0 1040 }; 1041 1042 struct iovec xcb_parts[4]; 1043 xcb_x_print_print_get_context_cookie_t xcb_ret; 1044 xcb_x_print_print_get_context_request_t xcb_out; 1045 1046 1047 xcb_parts[2].iov_base = (char *) &xcb_out; 1048 xcb_parts[2].iov_len = sizeof(xcb_out); 1049 xcb_parts[3].iov_base = 0; 1050 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1051 1052 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1053 return xcb_ret; 1054 } 1055 1056 1057 /***************************************************************************** 1058 ** 1059 ** xcb_x_print_print_get_context_reply_t * xcb_x_print_print_get_context_reply 1060 ** 1061 ** @param xcb_connection_t *c 1062 ** @param xcb_x_print_print_get_context_cookie_t cookie 1063 ** @param xcb_generic_error_t **e 1064 ** @returns xcb_x_print_print_get_context_reply_t * 1065 ** 1066 *****************************************************************************/ 1067 1068 xcb_x_print_print_get_context_reply_t * 1069 xcb_x_print_print_get_context_reply (xcb_connection_t *c /**< */, 1070 xcb_x_print_print_get_context_cookie_t cookie /**< */, 1071 xcb_generic_error_t **e /**< */) 1072 { 1073 return (xcb_x_print_print_get_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1074 } 1075 1076 1077 /***************************************************************************** 1078 ** 1079 ** xcb_void_cookie_t xcb_x_print_print_destroy_context_checked 1080 ** 1081 ** @param xcb_connection_t *c 1082 ** @param uint32_t context 1083 ** @returns xcb_void_cookie_t 1084 ** 1085 *****************************************************************************/ 1086 1087 xcb_void_cookie_t 1088 xcb_x_print_print_destroy_context_checked (xcb_connection_t *c /**< */, 1089 uint32_t context /**< */) 1090 { 1091 static const xcb_protocol_request_t xcb_req = { 1092 /* count */ 2, 1093 /* ext */ &xcb_x_print_id, 1094 /* opcode */ XCB_X_PRINT_PRINT_DESTROY_CONTEXT, 1095 /* isvoid */ 1 1096 }; 1097 1098 struct iovec xcb_parts[4]; 1099 xcb_void_cookie_t xcb_ret; 1100 xcb_x_print_print_destroy_context_request_t xcb_out; 1101 1102 xcb_out.context = context; 1103 1104 xcb_parts[2].iov_base = (char *) &xcb_out; 1105 xcb_parts[2].iov_len = sizeof(xcb_out); 1106 xcb_parts[3].iov_base = 0; 1107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1108 1109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1110 return xcb_ret; 1111 } 1112 1113 1114 /***************************************************************************** 1115 ** 1116 ** xcb_void_cookie_t xcb_x_print_print_destroy_context 1117 ** 1118 ** @param xcb_connection_t *c 1119 ** @param uint32_t context 1120 ** @returns xcb_void_cookie_t 1121 ** 1122 *****************************************************************************/ 1123 1124 xcb_void_cookie_t 1125 xcb_x_print_print_destroy_context (xcb_connection_t *c /**< */, 1126 uint32_t context /**< */) 1127 { 1128 static const xcb_protocol_request_t xcb_req = { 1129 /* count */ 2, 1130 /* ext */ &xcb_x_print_id, 1131 /* opcode */ XCB_X_PRINT_PRINT_DESTROY_CONTEXT, 1132 /* isvoid */ 1 1133 }; 1134 1135 struct iovec xcb_parts[4]; 1136 xcb_void_cookie_t xcb_ret; 1137 xcb_x_print_print_destroy_context_request_t xcb_out; 1138 1139 xcb_out.context = context; 1140 1141 xcb_parts[2].iov_base = (char *) &xcb_out; 1142 xcb_parts[2].iov_len = sizeof(xcb_out); 1143 xcb_parts[3].iov_base = 0; 1144 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1145 1146 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1147 return xcb_ret; 1148 } 1149 1150 1151 /***************************************************************************** 1152 ** 1153 ** xcb_x_print_print_get_screen_of_context_cookie_t xcb_x_print_print_get_screen_of_context 1154 ** 1155 ** @param xcb_connection_t *c 1156 ** @returns xcb_x_print_print_get_screen_of_context_cookie_t 1157 ** 1158 *****************************************************************************/ 1159 1160 xcb_x_print_print_get_screen_of_context_cookie_t 1161 xcb_x_print_print_get_screen_of_context (xcb_connection_t *c /**< */) 1162 { 1163 static const xcb_protocol_request_t xcb_req = { 1164 /* count */ 2, 1165 /* ext */ &xcb_x_print_id, 1166 /* opcode */ XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, 1167 /* isvoid */ 0 1168 }; 1169 1170 struct iovec xcb_parts[4]; 1171 xcb_x_print_print_get_screen_of_context_cookie_t xcb_ret; 1172 xcb_x_print_print_get_screen_of_context_request_t xcb_out; 1173 1174 1175 xcb_parts[2].iov_base = (char *) &xcb_out; 1176 xcb_parts[2].iov_len = sizeof(xcb_out); 1177 xcb_parts[3].iov_base = 0; 1178 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1179 1180 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1181 return xcb_ret; 1182 } 1183 1184 1185 /***************************************************************************** 1186 ** 1187 ** xcb_x_print_print_get_screen_of_context_cookie_t xcb_x_print_print_get_screen_of_context_unchecked 1188 ** 1189 ** @param xcb_connection_t *c 1190 ** @returns xcb_x_print_print_get_screen_of_context_cookie_t 1191 ** 1192 *****************************************************************************/ 1193 1194 xcb_x_print_print_get_screen_of_context_cookie_t 1195 xcb_x_print_print_get_screen_of_context_unchecked (xcb_connection_t *c /**< */) 1196 { 1197 static const xcb_protocol_request_t xcb_req = { 1198 /* count */ 2, 1199 /* ext */ &xcb_x_print_id, 1200 /* opcode */ XCB_X_PRINT_PRINT_GET_SCREEN_OF_CONTEXT, 1201 /* isvoid */ 0 1202 }; 1203 1204 struct iovec xcb_parts[4]; 1205 xcb_x_print_print_get_screen_of_context_cookie_t xcb_ret; 1206 xcb_x_print_print_get_screen_of_context_request_t xcb_out; 1207 1208 1209 xcb_parts[2].iov_base = (char *) &xcb_out; 1210 xcb_parts[2].iov_len = sizeof(xcb_out); 1211 xcb_parts[3].iov_base = 0; 1212 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1213 1214 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1215 return xcb_ret; 1216 } 1217 1218 1219 /***************************************************************************** 1220 ** 1221 ** xcb_x_print_print_get_screen_of_context_reply_t * xcb_x_print_print_get_screen_of_context_reply 1222 ** 1223 ** @param xcb_connection_t *c 1224 ** @param xcb_x_print_print_get_screen_of_context_cookie_t cookie 1225 ** @param xcb_generic_error_t **e 1226 ** @returns xcb_x_print_print_get_screen_of_context_reply_t * 1227 ** 1228 *****************************************************************************/ 1229 1230 xcb_x_print_print_get_screen_of_context_reply_t * 1231 xcb_x_print_print_get_screen_of_context_reply (xcb_connection_t *c /**< */, 1232 xcb_x_print_print_get_screen_of_context_cookie_t cookie /**< */, 1233 xcb_generic_error_t **e /**< */) 1234 { 1235 return (xcb_x_print_print_get_screen_of_context_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1236 } 1237 1238 1239 /***************************************************************************** 1240 ** 1241 ** xcb_void_cookie_t xcb_x_print_print_start_job_checked 1242 ** 1243 ** @param xcb_connection_t *c 1244 ** @param uint8_t output_mode 1245 ** @returns xcb_void_cookie_t 1246 ** 1247 *****************************************************************************/ 1248 1249 xcb_void_cookie_t 1250 xcb_x_print_print_start_job_checked (xcb_connection_t *c /**< */, 1251 uint8_t output_mode /**< */) 1252 { 1253 static const xcb_protocol_request_t xcb_req = { 1254 /* count */ 2, 1255 /* ext */ &xcb_x_print_id, 1256 /* opcode */ XCB_X_PRINT_PRINT_START_JOB, 1257 /* isvoid */ 1 1258 }; 1259 1260 struct iovec xcb_parts[4]; 1261 xcb_void_cookie_t xcb_ret; 1262 xcb_x_print_print_start_job_request_t xcb_out; 1263 1264 xcb_out.output_mode = output_mode; 1265 1266 xcb_parts[2].iov_base = (char *) &xcb_out; 1267 xcb_parts[2].iov_len = sizeof(xcb_out); 1268 xcb_parts[3].iov_base = 0; 1269 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1270 1271 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1272 return xcb_ret; 1273 } 1274 1275 1276 /***************************************************************************** 1277 ** 1278 ** xcb_void_cookie_t xcb_x_print_print_start_job 1279 ** 1280 ** @param xcb_connection_t *c 1281 ** @param uint8_t output_mode 1282 ** @returns xcb_void_cookie_t 1283 ** 1284 *****************************************************************************/ 1285 1286 xcb_void_cookie_t 1287 xcb_x_print_print_start_job (xcb_connection_t *c /**< */, 1288 uint8_t output_mode /**< */) 1289 { 1290 static const xcb_protocol_request_t xcb_req = { 1291 /* count */ 2, 1292 /* ext */ &xcb_x_print_id, 1293 /* opcode */ XCB_X_PRINT_PRINT_START_JOB, 1294 /* isvoid */ 1 1295 }; 1296 1297 struct iovec xcb_parts[4]; 1298 xcb_void_cookie_t xcb_ret; 1299 xcb_x_print_print_start_job_request_t xcb_out; 1300 1301 xcb_out.output_mode = output_mode; 1302 1303 xcb_parts[2].iov_base = (char *) &xcb_out; 1304 xcb_parts[2].iov_len = sizeof(xcb_out); 1305 xcb_parts[3].iov_base = 0; 1306 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1307 1308 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1309 return xcb_ret; 1310 } 1311 1312 1313 /***************************************************************************** 1314 ** 1315 ** xcb_void_cookie_t xcb_x_print_print_end_job_checked 1316 ** 1317 ** @param xcb_connection_t *c 1318 ** @param uint8_t cancel 1319 ** @returns xcb_void_cookie_t 1320 ** 1321 *****************************************************************************/ 1322 1323 xcb_void_cookie_t 1324 xcb_x_print_print_end_job_checked (xcb_connection_t *c /**< */, 1325 uint8_t cancel /**< */) 1326 { 1327 static const xcb_protocol_request_t xcb_req = { 1328 /* count */ 2, 1329 /* ext */ &xcb_x_print_id, 1330 /* opcode */ XCB_X_PRINT_PRINT_END_JOB, 1331 /* isvoid */ 1 1332 }; 1333 1334 struct iovec xcb_parts[4]; 1335 xcb_void_cookie_t xcb_ret; 1336 xcb_x_print_print_end_job_request_t xcb_out; 1337 1338 xcb_out.cancel = cancel; 1339 1340 xcb_parts[2].iov_base = (char *) &xcb_out; 1341 xcb_parts[2].iov_len = sizeof(xcb_out); 1342 xcb_parts[3].iov_base = 0; 1343 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1344 1345 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1346 return xcb_ret; 1347 } 1348 1349 1350 /***************************************************************************** 1351 ** 1352 ** xcb_void_cookie_t xcb_x_print_print_end_job 1353 ** 1354 ** @param xcb_connection_t *c 1355 ** @param uint8_t cancel 1356 ** @returns xcb_void_cookie_t 1357 ** 1358 *****************************************************************************/ 1359 1360 xcb_void_cookie_t 1361 xcb_x_print_print_end_job (xcb_connection_t *c /**< */, 1362 uint8_t cancel /**< */) 1363 { 1364 static const xcb_protocol_request_t xcb_req = { 1365 /* count */ 2, 1366 /* ext */ &xcb_x_print_id, 1367 /* opcode */ XCB_X_PRINT_PRINT_END_JOB, 1368 /* isvoid */ 1 1369 }; 1370 1371 struct iovec xcb_parts[4]; 1372 xcb_void_cookie_t xcb_ret; 1373 xcb_x_print_print_end_job_request_t xcb_out; 1374 1375 xcb_out.cancel = cancel; 1376 1377 xcb_parts[2].iov_base = (char *) &xcb_out; 1378 xcb_parts[2].iov_len = sizeof(xcb_out); 1379 xcb_parts[3].iov_base = 0; 1380 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1381 1382 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1383 return xcb_ret; 1384 } 1385 1386 1387 /***************************************************************************** 1388 ** 1389 ** xcb_void_cookie_t xcb_x_print_print_start_doc_checked 1390 ** 1391 ** @param xcb_connection_t *c 1392 ** @param uint8_t driver_mode 1393 ** @returns xcb_void_cookie_t 1394 ** 1395 *****************************************************************************/ 1396 1397 xcb_void_cookie_t 1398 xcb_x_print_print_start_doc_checked (xcb_connection_t *c /**< */, 1399 uint8_t driver_mode /**< */) 1400 { 1401 static const xcb_protocol_request_t xcb_req = { 1402 /* count */ 2, 1403 /* ext */ &xcb_x_print_id, 1404 /* opcode */ XCB_X_PRINT_PRINT_START_DOC, 1405 /* isvoid */ 1 1406 }; 1407 1408 struct iovec xcb_parts[4]; 1409 xcb_void_cookie_t xcb_ret; 1410 xcb_x_print_print_start_doc_request_t xcb_out; 1411 1412 xcb_out.driver_mode = driver_mode; 1413 1414 xcb_parts[2].iov_base = (char *) &xcb_out; 1415 xcb_parts[2].iov_len = sizeof(xcb_out); 1416 xcb_parts[3].iov_base = 0; 1417 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1418 1419 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1420 return xcb_ret; 1421 } 1422 1423 1424 /***************************************************************************** 1425 ** 1426 ** xcb_void_cookie_t xcb_x_print_print_start_doc 1427 ** 1428 ** @param xcb_connection_t *c 1429 ** @param uint8_t driver_mode 1430 ** @returns xcb_void_cookie_t 1431 ** 1432 *****************************************************************************/ 1433 1434 xcb_void_cookie_t 1435 xcb_x_print_print_start_doc (xcb_connection_t *c /**< */, 1436 uint8_t driver_mode /**< */) 1437 { 1438 static const xcb_protocol_request_t xcb_req = { 1439 /* count */ 2, 1440 /* ext */ &xcb_x_print_id, 1441 /* opcode */ XCB_X_PRINT_PRINT_START_DOC, 1442 /* isvoid */ 1 1443 }; 1444 1445 struct iovec xcb_parts[4]; 1446 xcb_void_cookie_t xcb_ret; 1447 xcb_x_print_print_start_doc_request_t xcb_out; 1448 1449 xcb_out.driver_mode = driver_mode; 1450 1451 xcb_parts[2].iov_base = (char *) &xcb_out; 1452 xcb_parts[2].iov_len = sizeof(xcb_out); 1453 xcb_parts[3].iov_base = 0; 1454 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1455 1456 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1457 return xcb_ret; 1458 } 1459 1460 1461 /***************************************************************************** 1462 ** 1463 ** xcb_void_cookie_t xcb_x_print_print_end_doc_checked 1464 ** 1465 ** @param xcb_connection_t *c 1466 ** @param uint8_t cancel 1467 ** @returns xcb_void_cookie_t 1468 ** 1469 *****************************************************************************/ 1470 1471 xcb_void_cookie_t 1472 xcb_x_print_print_end_doc_checked (xcb_connection_t *c /**< */, 1473 uint8_t cancel /**< */) 1474 { 1475 static const xcb_protocol_request_t xcb_req = { 1476 /* count */ 2, 1477 /* ext */ &xcb_x_print_id, 1478 /* opcode */ XCB_X_PRINT_PRINT_END_DOC, 1479 /* isvoid */ 1 1480 }; 1481 1482 struct iovec xcb_parts[4]; 1483 xcb_void_cookie_t xcb_ret; 1484 xcb_x_print_print_end_doc_request_t xcb_out; 1485 1486 xcb_out.cancel = cancel; 1487 1488 xcb_parts[2].iov_base = (char *) &xcb_out; 1489 xcb_parts[2].iov_len = sizeof(xcb_out); 1490 xcb_parts[3].iov_base = 0; 1491 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1492 1493 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1494 return xcb_ret; 1495 } 1496 1497 1498 /***************************************************************************** 1499 ** 1500 ** xcb_void_cookie_t xcb_x_print_print_end_doc 1501 ** 1502 ** @param xcb_connection_t *c 1503 ** @param uint8_t cancel 1504 ** @returns xcb_void_cookie_t 1505 ** 1506 *****************************************************************************/ 1507 1508 xcb_void_cookie_t 1509 xcb_x_print_print_end_doc (xcb_connection_t *c /**< */, 1510 uint8_t cancel /**< */) 1511 { 1512 static const xcb_protocol_request_t xcb_req = { 1513 /* count */ 2, 1514 /* ext */ &xcb_x_print_id, 1515 /* opcode */ XCB_X_PRINT_PRINT_END_DOC, 1516 /* isvoid */ 1 1517 }; 1518 1519 struct iovec xcb_parts[4]; 1520 xcb_void_cookie_t xcb_ret; 1521 xcb_x_print_print_end_doc_request_t xcb_out; 1522 1523 xcb_out.cancel = cancel; 1524 1525 xcb_parts[2].iov_base = (char *) &xcb_out; 1526 xcb_parts[2].iov_len = sizeof(xcb_out); 1527 xcb_parts[3].iov_base = 0; 1528 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1529 1530 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1531 return xcb_ret; 1532 } 1533 1534 int 1535 xcb_x_print_print_put_document_data_sizeof (const void *_buffer /**< */, 1536 uint32_t doc_format_len /**< */, 1537 uint32_t options_len /**< */) 1538 { 1539 char *xcb_tmp = (char *)_buffer; 1540 const xcb_x_print_print_put_document_data_request_t *_aux = (xcb_x_print_print_put_document_data_request_t *)_buffer; 1541 unsigned int xcb_buffer_len = 0; 1542 unsigned int xcb_block_len = 0; 1543 unsigned int xcb_pad = 0; 1544 unsigned int xcb_align_to; 1545 1546 1547 xcb_block_len += sizeof(xcb_x_print_print_put_document_data_request_t); 1548 xcb_tmp += xcb_block_len; 1549 /* data */ 1550 xcb_block_len += _aux->len_data * sizeof(uint8_t); 1551 xcb_tmp += xcb_block_len; 1552 xcb_align_to = ALIGNOF(uint8_t); 1553 /* insert padding */ 1554 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1555 xcb_buffer_len += xcb_block_len + xcb_pad; 1556 if (0 != xcb_pad) { 1557 xcb_tmp += xcb_pad; 1558 xcb_pad = 0; 1559 } 1560 xcb_block_len = 0; 1561 /* doc_format */ 1562 xcb_block_len += doc_format_len * sizeof(xcb_x_print_string8_t); 1563 xcb_tmp += xcb_block_len; 1564 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 1565 /* insert padding */ 1566 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1567 xcb_buffer_len += xcb_block_len + xcb_pad; 1568 if (0 != xcb_pad) { 1569 xcb_tmp += xcb_pad; 1570 xcb_pad = 0; 1571 } 1572 xcb_block_len = 0; 1573 /* options */ 1574 xcb_block_len += options_len * sizeof(xcb_x_print_string8_t); 1575 xcb_tmp += xcb_block_len; 1576 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 1577 /* insert padding */ 1578 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1579 xcb_buffer_len += xcb_block_len + xcb_pad; 1580 if (0 != xcb_pad) { 1581 xcb_tmp += xcb_pad; 1582 xcb_pad = 0; 1583 } 1584 xcb_block_len = 0; 1585 1586 return xcb_buffer_len; 1587 } 1588 1589 1590 /***************************************************************************** 1591 ** 1592 ** xcb_void_cookie_t xcb_x_print_print_put_document_data_checked 1593 ** 1594 ** @param xcb_connection_t *c 1595 ** @param xcb_drawable_t drawable 1596 ** @param uint32_t len_data 1597 ** @param uint16_t len_fmt 1598 ** @param uint16_t len_options 1599 ** @param const uint8_t *data 1600 ** @param uint32_t doc_format_len 1601 ** @param const xcb_x_print_string8_t *doc_format 1602 ** @param uint32_t options_len 1603 ** @param const xcb_x_print_string8_t *options 1604 ** @returns xcb_void_cookie_t 1605 ** 1606 *****************************************************************************/ 1607 1608 xcb_void_cookie_t 1609 xcb_x_print_print_put_document_data_checked (xcb_connection_t *c /**< */, 1610 xcb_drawable_t drawable /**< */, 1611 uint32_t len_data /**< */, 1612 uint16_t len_fmt /**< */, 1613 uint16_t len_options /**< */, 1614 const uint8_t *data /**< */, 1615 uint32_t doc_format_len /**< */, 1616 const xcb_x_print_string8_t *doc_format /**< */, 1617 uint32_t options_len /**< */, 1618 const xcb_x_print_string8_t *options /**< */) 1619 { 1620 static const xcb_protocol_request_t xcb_req = { 1621 /* count */ 8, 1622 /* ext */ &xcb_x_print_id, 1623 /* opcode */ XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, 1624 /* isvoid */ 1 1625 }; 1626 1627 struct iovec xcb_parts[10]; 1628 xcb_void_cookie_t xcb_ret; 1629 xcb_x_print_print_put_document_data_request_t xcb_out; 1630 1631 xcb_out.drawable = drawable; 1632 xcb_out.len_data = len_data; 1633 xcb_out.len_fmt = len_fmt; 1634 xcb_out.len_options = len_options; 1635 1636 xcb_parts[2].iov_base = (char *) &xcb_out; 1637 xcb_parts[2].iov_len = sizeof(xcb_out); 1638 xcb_parts[3].iov_base = 0; 1639 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1640 /* uint8_t data */ 1641 xcb_parts[4].iov_base = (char *) data; 1642 xcb_parts[4].iov_len = len_data * sizeof(uint8_t); 1643 xcb_parts[5].iov_base = 0; 1644 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1645 /* xcb_x_print_string8_t doc_format */ 1646 xcb_parts[6].iov_base = (char *) doc_format; 1647 xcb_parts[6].iov_len = doc_format_len * sizeof(xcb_x_print_string8_t); 1648 xcb_parts[7].iov_base = 0; 1649 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 1650 /* xcb_x_print_string8_t options */ 1651 xcb_parts[8].iov_base = (char *) options; 1652 xcb_parts[8].iov_len = options_len * sizeof(xcb_x_print_string8_t); 1653 xcb_parts[9].iov_base = 0; 1654 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 1655 1656 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1657 return xcb_ret; 1658 } 1659 1660 1661 /***************************************************************************** 1662 ** 1663 ** xcb_void_cookie_t xcb_x_print_print_put_document_data 1664 ** 1665 ** @param xcb_connection_t *c 1666 ** @param xcb_drawable_t drawable 1667 ** @param uint32_t len_data 1668 ** @param uint16_t len_fmt 1669 ** @param uint16_t len_options 1670 ** @param const uint8_t *data 1671 ** @param uint32_t doc_format_len 1672 ** @param const xcb_x_print_string8_t *doc_format 1673 ** @param uint32_t options_len 1674 ** @param const xcb_x_print_string8_t *options 1675 ** @returns xcb_void_cookie_t 1676 ** 1677 *****************************************************************************/ 1678 1679 xcb_void_cookie_t 1680 xcb_x_print_print_put_document_data (xcb_connection_t *c /**< */, 1681 xcb_drawable_t drawable /**< */, 1682 uint32_t len_data /**< */, 1683 uint16_t len_fmt /**< */, 1684 uint16_t len_options /**< */, 1685 const uint8_t *data /**< */, 1686 uint32_t doc_format_len /**< */, 1687 const xcb_x_print_string8_t *doc_format /**< */, 1688 uint32_t options_len /**< */, 1689 const xcb_x_print_string8_t *options /**< */) 1690 { 1691 static const xcb_protocol_request_t xcb_req = { 1692 /* count */ 8, 1693 /* ext */ &xcb_x_print_id, 1694 /* opcode */ XCB_X_PRINT_PRINT_PUT_DOCUMENT_DATA, 1695 /* isvoid */ 1 1696 }; 1697 1698 struct iovec xcb_parts[10]; 1699 xcb_void_cookie_t xcb_ret; 1700 xcb_x_print_print_put_document_data_request_t xcb_out; 1701 1702 xcb_out.drawable = drawable; 1703 xcb_out.len_data = len_data; 1704 xcb_out.len_fmt = len_fmt; 1705 xcb_out.len_options = len_options; 1706 1707 xcb_parts[2].iov_base = (char *) &xcb_out; 1708 xcb_parts[2].iov_len = sizeof(xcb_out); 1709 xcb_parts[3].iov_base = 0; 1710 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1711 /* uint8_t data */ 1712 xcb_parts[4].iov_base = (char *) data; 1713 xcb_parts[4].iov_len = len_data * sizeof(uint8_t); 1714 xcb_parts[5].iov_base = 0; 1715 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 1716 /* xcb_x_print_string8_t doc_format */ 1717 xcb_parts[6].iov_base = (char *) doc_format; 1718 xcb_parts[6].iov_len = doc_format_len * sizeof(xcb_x_print_string8_t); 1719 xcb_parts[7].iov_base = 0; 1720 xcb_parts[7].iov_len = -xcb_parts[6].iov_len & 3; 1721 /* xcb_x_print_string8_t options */ 1722 xcb_parts[8].iov_base = (char *) options; 1723 xcb_parts[8].iov_len = options_len * sizeof(xcb_x_print_string8_t); 1724 xcb_parts[9].iov_base = 0; 1725 xcb_parts[9].iov_len = -xcb_parts[8].iov_len & 3; 1726 1727 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1728 return xcb_ret; 1729 } 1730 1731 int 1732 xcb_x_print_print_get_document_data_sizeof (const void *_buffer /**< */) 1733 { 1734 char *xcb_tmp = (char *)_buffer; 1735 const xcb_x_print_print_get_document_data_reply_t *_aux = (xcb_x_print_print_get_document_data_reply_t *)_buffer; 1736 unsigned int xcb_buffer_len = 0; 1737 unsigned int xcb_block_len = 0; 1738 unsigned int xcb_pad = 0; 1739 unsigned int xcb_align_to; 1740 1741 1742 xcb_block_len += sizeof(xcb_x_print_print_get_document_data_reply_t); 1743 xcb_tmp += xcb_block_len; 1744 /* data */ 1745 xcb_block_len += _aux->dataLen * sizeof(uint8_t); 1746 xcb_tmp += xcb_block_len; 1747 xcb_align_to = ALIGNOF(uint8_t); 1748 /* insert padding */ 1749 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 1750 xcb_buffer_len += xcb_block_len + xcb_pad; 1751 if (0 != xcb_pad) { 1752 xcb_tmp += xcb_pad; 1753 xcb_pad = 0; 1754 } 1755 xcb_block_len = 0; 1756 1757 return xcb_buffer_len; 1758 } 1759 1760 1761 /***************************************************************************** 1762 ** 1763 ** xcb_x_print_print_get_document_data_cookie_t xcb_x_print_print_get_document_data 1764 ** 1765 ** @param xcb_connection_t *c 1766 ** @param xcb_x_print_pcontext_t context 1767 ** @param uint32_t max_bytes 1768 ** @returns xcb_x_print_print_get_document_data_cookie_t 1769 ** 1770 *****************************************************************************/ 1771 1772 xcb_x_print_print_get_document_data_cookie_t 1773 xcb_x_print_print_get_document_data (xcb_connection_t *c /**< */, 1774 xcb_x_print_pcontext_t context /**< */, 1775 uint32_t max_bytes /**< */) 1776 { 1777 static const xcb_protocol_request_t xcb_req = { 1778 /* count */ 2, 1779 /* ext */ &xcb_x_print_id, 1780 /* opcode */ XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, 1781 /* isvoid */ 0 1782 }; 1783 1784 struct iovec xcb_parts[4]; 1785 xcb_x_print_print_get_document_data_cookie_t xcb_ret; 1786 xcb_x_print_print_get_document_data_request_t xcb_out; 1787 1788 xcb_out.context = context; 1789 xcb_out.max_bytes = max_bytes; 1790 1791 xcb_parts[2].iov_base = (char *) &xcb_out; 1792 xcb_parts[2].iov_len = sizeof(xcb_out); 1793 xcb_parts[3].iov_base = 0; 1794 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1795 1796 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1797 return xcb_ret; 1798 } 1799 1800 1801 /***************************************************************************** 1802 ** 1803 ** xcb_x_print_print_get_document_data_cookie_t xcb_x_print_print_get_document_data_unchecked 1804 ** 1805 ** @param xcb_connection_t *c 1806 ** @param xcb_x_print_pcontext_t context 1807 ** @param uint32_t max_bytes 1808 ** @returns xcb_x_print_print_get_document_data_cookie_t 1809 ** 1810 *****************************************************************************/ 1811 1812 xcb_x_print_print_get_document_data_cookie_t 1813 xcb_x_print_print_get_document_data_unchecked (xcb_connection_t *c /**< */, 1814 xcb_x_print_pcontext_t context /**< */, 1815 uint32_t max_bytes /**< */) 1816 { 1817 static const xcb_protocol_request_t xcb_req = { 1818 /* count */ 2, 1819 /* ext */ &xcb_x_print_id, 1820 /* opcode */ XCB_X_PRINT_PRINT_GET_DOCUMENT_DATA, 1821 /* isvoid */ 0 1822 }; 1823 1824 struct iovec xcb_parts[4]; 1825 xcb_x_print_print_get_document_data_cookie_t xcb_ret; 1826 xcb_x_print_print_get_document_data_request_t xcb_out; 1827 1828 xcb_out.context = context; 1829 xcb_out.max_bytes = max_bytes; 1830 1831 xcb_parts[2].iov_base = (char *) &xcb_out; 1832 xcb_parts[2].iov_len = sizeof(xcb_out); 1833 xcb_parts[3].iov_base = 0; 1834 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1835 1836 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1837 return xcb_ret; 1838 } 1839 1840 1841 /***************************************************************************** 1842 ** 1843 ** uint8_t * xcb_x_print_print_get_document_data_data 1844 ** 1845 ** @param const xcb_x_print_print_get_document_data_reply_t *R 1846 ** @returns uint8_t * 1847 ** 1848 *****************************************************************************/ 1849 1850 uint8_t * 1851 xcb_x_print_print_get_document_data_data (const xcb_x_print_print_get_document_data_reply_t *R /**< */) 1852 { 1853 return (uint8_t *) (R + 1); 1854 } 1855 1856 1857 /***************************************************************************** 1858 ** 1859 ** int xcb_x_print_print_get_document_data_data_length 1860 ** 1861 ** @param const xcb_x_print_print_get_document_data_reply_t *R 1862 ** @returns int 1863 ** 1864 *****************************************************************************/ 1865 1866 int 1867 xcb_x_print_print_get_document_data_data_length (const xcb_x_print_print_get_document_data_reply_t *R /**< */) 1868 { 1869 return R->dataLen; 1870 } 1871 1872 1873 /***************************************************************************** 1874 ** 1875 ** xcb_generic_iterator_t xcb_x_print_print_get_document_data_data_end 1876 ** 1877 ** @param const xcb_x_print_print_get_document_data_reply_t *R 1878 ** @returns xcb_generic_iterator_t 1879 ** 1880 *****************************************************************************/ 1881 1882 xcb_generic_iterator_t 1883 xcb_x_print_print_get_document_data_data_end (const xcb_x_print_print_get_document_data_reply_t *R /**< */) 1884 { 1885 xcb_generic_iterator_t i; 1886 i.data = ((uint8_t *) (R + 1)) + (R->dataLen); 1887 i.rem = 0; 1888 i.index = (char *) i.data - (char *) R; 1889 return i; 1890 } 1891 1892 1893 /***************************************************************************** 1894 ** 1895 ** xcb_x_print_print_get_document_data_reply_t * xcb_x_print_print_get_document_data_reply 1896 ** 1897 ** @param xcb_connection_t *c 1898 ** @param xcb_x_print_print_get_document_data_cookie_t cookie 1899 ** @param xcb_generic_error_t **e 1900 ** @returns xcb_x_print_print_get_document_data_reply_t * 1901 ** 1902 *****************************************************************************/ 1903 1904 xcb_x_print_print_get_document_data_reply_t * 1905 xcb_x_print_print_get_document_data_reply (xcb_connection_t *c /**< */, 1906 xcb_x_print_print_get_document_data_cookie_t cookie /**< */, 1907 xcb_generic_error_t **e /**< */) 1908 { 1909 return (xcb_x_print_print_get_document_data_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 1910 } 1911 1912 1913 /***************************************************************************** 1914 ** 1915 ** xcb_void_cookie_t xcb_x_print_print_start_page_checked 1916 ** 1917 ** @param xcb_connection_t *c 1918 ** @param xcb_window_t window 1919 ** @returns xcb_void_cookie_t 1920 ** 1921 *****************************************************************************/ 1922 1923 xcb_void_cookie_t 1924 xcb_x_print_print_start_page_checked (xcb_connection_t *c /**< */, 1925 xcb_window_t window /**< */) 1926 { 1927 static const xcb_protocol_request_t xcb_req = { 1928 /* count */ 2, 1929 /* ext */ &xcb_x_print_id, 1930 /* opcode */ XCB_X_PRINT_PRINT_START_PAGE, 1931 /* isvoid */ 1 1932 }; 1933 1934 struct iovec xcb_parts[4]; 1935 xcb_void_cookie_t xcb_ret; 1936 xcb_x_print_print_start_page_request_t xcb_out; 1937 1938 xcb_out.window = window; 1939 1940 xcb_parts[2].iov_base = (char *) &xcb_out; 1941 xcb_parts[2].iov_len = sizeof(xcb_out); 1942 xcb_parts[3].iov_base = 0; 1943 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1944 1945 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 1946 return xcb_ret; 1947 } 1948 1949 1950 /***************************************************************************** 1951 ** 1952 ** xcb_void_cookie_t xcb_x_print_print_start_page 1953 ** 1954 ** @param xcb_connection_t *c 1955 ** @param xcb_window_t window 1956 ** @returns xcb_void_cookie_t 1957 ** 1958 *****************************************************************************/ 1959 1960 xcb_void_cookie_t 1961 xcb_x_print_print_start_page (xcb_connection_t *c /**< */, 1962 xcb_window_t window /**< */) 1963 { 1964 static const xcb_protocol_request_t xcb_req = { 1965 /* count */ 2, 1966 /* ext */ &xcb_x_print_id, 1967 /* opcode */ XCB_X_PRINT_PRINT_START_PAGE, 1968 /* isvoid */ 1 1969 }; 1970 1971 struct iovec xcb_parts[4]; 1972 xcb_void_cookie_t xcb_ret; 1973 xcb_x_print_print_start_page_request_t xcb_out; 1974 1975 xcb_out.window = window; 1976 1977 xcb_parts[2].iov_base = (char *) &xcb_out; 1978 xcb_parts[2].iov_len = sizeof(xcb_out); 1979 xcb_parts[3].iov_base = 0; 1980 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 1981 1982 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 1983 return xcb_ret; 1984 } 1985 1986 1987 /***************************************************************************** 1988 ** 1989 ** xcb_void_cookie_t xcb_x_print_print_end_page_checked 1990 ** 1991 ** @param xcb_connection_t *c 1992 ** @param uint8_t cancel 1993 ** @returns xcb_void_cookie_t 1994 ** 1995 *****************************************************************************/ 1996 1997 xcb_void_cookie_t 1998 xcb_x_print_print_end_page_checked (xcb_connection_t *c /**< */, 1999 uint8_t cancel /**< */) 2000 { 2001 static const xcb_protocol_request_t xcb_req = { 2002 /* count */ 2, 2003 /* ext */ &xcb_x_print_id, 2004 /* opcode */ XCB_X_PRINT_PRINT_END_PAGE, 2005 /* isvoid */ 1 2006 }; 2007 2008 struct iovec xcb_parts[4]; 2009 xcb_void_cookie_t xcb_ret; 2010 xcb_x_print_print_end_page_request_t xcb_out; 2011 2012 xcb_out.cancel = cancel; 2013 memset(xcb_out.pad0, 0, 3); 2014 2015 xcb_parts[2].iov_base = (char *) &xcb_out; 2016 xcb_parts[2].iov_len = sizeof(xcb_out); 2017 xcb_parts[3].iov_base = 0; 2018 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2019 2020 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2021 return xcb_ret; 2022 } 2023 2024 2025 /***************************************************************************** 2026 ** 2027 ** xcb_void_cookie_t xcb_x_print_print_end_page 2028 ** 2029 ** @param xcb_connection_t *c 2030 ** @param uint8_t cancel 2031 ** @returns xcb_void_cookie_t 2032 ** 2033 *****************************************************************************/ 2034 2035 xcb_void_cookie_t 2036 xcb_x_print_print_end_page (xcb_connection_t *c /**< */, 2037 uint8_t cancel /**< */) 2038 { 2039 static const xcb_protocol_request_t xcb_req = { 2040 /* count */ 2, 2041 /* ext */ &xcb_x_print_id, 2042 /* opcode */ XCB_X_PRINT_PRINT_END_PAGE, 2043 /* isvoid */ 1 2044 }; 2045 2046 struct iovec xcb_parts[4]; 2047 xcb_void_cookie_t xcb_ret; 2048 xcb_x_print_print_end_page_request_t xcb_out; 2049 2050 xcb_out.cancel = cancel; 2051 memset(xcb_out.pad0, 0, 3); 2052 2053 xcb_parts[2].iov_base = (char *) &xcb_out; 2054 xcb_parts[2].iov_len = sizeof(xcb_out); 2055 xcb_parts[3].iov_base = 0; 2056 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2057 2058 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2059 return xcb_ret; 2060 } 2061 2062 int 2063 xcb_x_print_print_select_input_sizeof (const void *_buffer /**< */) 2064 { 2065 char *xcb_tmp = (char *)_buffer; 2066 const xcb_x_print_print_select_input_request_t *_aux = (xcb_x_print_print_select_input_request_t *)_buffer; 2067 unsigned int xcb_buffer_len = 0; 2068 unsigned int xcb_block_len = 0; 2069 unsigned int xcb_pad = 0; 2070 unsigned int xcb_align_to; 2071 2072 2073 xcb_block_len += sizeof(xcb_x_print_print_select_input_request_t); 2074 xcb_tmp += xcb_block_len; 2075 /* event_list */ 2076 xcb_block_len += xcb_popcount(_aux->event_mask) * sizeof(uint32_t); 2077 xcb_tmp += xcb_block_len; 2078 xcb_align_to = ALIGNOF(uint32_t); 2079 /* insert padding */ 2080 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2081 xcb_buffer_len += xcb_block_len + xcb_pad; 2082 if (0 != xcb_pad) { 2083 xcb_tmp += xcb_pad; 2084 xcb_pad = 0; 2085 } 2086 xcb_block_len = 0; 2087 2088 return xcb_buffer_len; 2089 } 2090 2091 2092 /***************************************************************************** 2093 ** 2094 ** xcb_void_cookie_t xcb_x_print_print_select_input_checked 2095 ** 2096 ** @param xcb_connection_t *c 2097 ** @param xcb_x_print_pcontext_t context 2098 ** @param uint32_t event_mask 2099 ** @param const uint32_t *event_list 2100 ** @returns xcb_void_cookie_t 2101 ** 2102 *****************************************************************************/ 2103 2104 xcb_void_cookie_t 2105 xcb_x_print_print_select_input_checked (xcb_connection_t *c /**< */, 2106 xcb_x_print_pcontext_t context /**< */, 2107 uint32_t event_mask /**< */, 2108 const uint32_t *event_list /**< */) 2109 { 2110 static const xcb_protocol_request_t xcb_req = { 2111 /* count */ 4, 2112 /* ext */ &xcb_x_print_id, 2113 /* opcode */ XCB_X_PRINT_PRINT_SELECT_INPUT, 2114 /* isvoid */ 1 2115 }; 2116 2117 struct iovec xcb_parts[6]; 2118 xcb_void_cookie_t xcb_ret; 2119 xcb_x_print_print_select_input_request_t xcb_out; 2120 2121 xcb_out.context = context; 2122 xcb_out.event_mask = event_mask; 2123 2124 xcb_parts[2].iov_base = (char *) &xcb_out; 2125 xcb_parts[2].iov_len = sizeof(xcb_out); 2126 xcb_parts[3].iov_base = 0; 2127 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2128 /* uint32_t event_list */ 2129 xcb_parts[4].iov_base = (char *) event_list; 2130 xcb_parts[4].iov_len = xcb_popcount(event_mask) * sizeof(uint32_t); 2131 xcb_parts[5].iov_base = 0; 2132 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2133 2134 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2135 return xcb_ret; 2136 } 2137 2138 2139 /***************************************************************************** 2140 ** 2141 ** xcb_void_cookie_t xcb_x_print_print_select_input 2142 ** 2143 ** @param xcb_connection_t *c 2144 ** @param xcb_x_print_pcontext_t context 2145 ** @param uint32_t event_mask 2146 ** @param const uint32_t *event_list 2147 ** @returns xcb_void_cookie_t 2148 ** 2149 *****************************************************************************/ 2150 2151 xcb_void_cookie_t 2152 xcb_x_print_print_select_input (xcb_connection_t *c /**< */, 2153 xcb_x_print_pcontext_t context /**< */, 2154 uint32_t event_mask /**< */, 2155 const uint32_t *event_list /**< */) 2156 { 2157 static const xcb_protocol_request_t xcb_req = { 2158 /* count */ 4, 2159 /* ext */ &xcb_x_print_id, 2160 /* opcode */ XCB_X_PRINT_PRINT_SELECT_INPUT, 2161 /* isvoid */ 1 2162 }; 2163 2164 struct iovec xcb_parts[6]; 2165 xcb_void_cookie_t xcb_ret; 2166 xcb_x_print_print_select_input_request_t xcb_out; 2167 2168 xcb_out.context = context; 2169 xcb_out.event_mask = event_mask; 2170 2171 xcb_parts[2].iov_base = (char *) &xcb_out; 2172 xcb_parts[2].iov_len = sizeof(xcb_out); 2173 xcb_parts[3].iov_base = 0; 2174 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2175 /* uint32_t event_list */ 2176 xcb_parts[4].iov_base = (char *) event_list; 2177 xcb_parts[4].iov_len = xcb_popcount(event_mask) * sizeof(uint32_t); 2178 xcb_parts[5].iov_base = 0; 2179 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2180 2181 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2182 return xcb_ret; 2183 } 2184 2185 int 2186 xcb_x_print_print_input_selected_serialize (void **_buffer /**< */, 2187 const xcb_x_print_print_input_selected_reply_t *_aux /**< */, 2188 const uint32_t *event_list /**< */, 2189 const uint32_t *all_events_list /**< */) 2190 { 2191 char *xcb_out = *_buffer; 2192 unsigned int xcb_buffer_len = 0; 2193 unsigned int xcb_align_to; 2194 2195 unsigned int xcb_pad = 0; 2196 char xcb_pad0[3] = {0, 0, 0}; 2197 struct iovec xcb_parts[6]; 2198 unsigned int xcb_parts_idx = 0; 2199 unsigned int xcb_block_len = 0; 2200 unsigned int i; 2201 char *xcb_tmp; 2202 2203 /* xcb_x_print_print_input_selected_reply_t.pad0 */ 2204 xcb_parts[xcb_parts_idx].iov_base = (char *) &xcb_pad; 2205 xcb_block_len += sizeof(uint8_t); 2206 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint8_t); 2207 xcb_parts_idx++; 2208 xcb_align_to = ALIGNOF(uint8_t); 2209 /* xcb_x_print_print_input_selected_reply_t.event_mask */ 2210 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; 2211 xcb_block_len += sizeof(uint32_t); 2212 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 2213 xcb_parts_idx++; 2214 xcb_align_to = ALIGNOF(uint32_t); 2215 /* event_list */ 2216 xcb_parts[xcb_parts_idx].iov_base = (char *) event_list; 2217 xcb_block_len += xcb_popcount(_aux->event_mask) * sizeof(uint32_t); 2218 xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->event_mask) * sizeof(uint32_t); 2219 xcb_parts_idx++; 2220 xcb_align_to = ALIGNOF(uint32_t); 2221 /* xcb_x_print_print_input_selected_reply_t.all_events_mask */ 2222 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->all_events_mask; 2223 xcb_block_len += sizeof(uint32_t); 2224 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 2225 xcb_parts_idx++; 2226 xcb_align_to = ALIGNOF(uint32_t); 2227 /* all_events_list */ 2228 xcb_parts[xcb_parts_idx].iov_base = (char *) all_events_list; 2229 xcb_block_len += xcb_popcount(_aux->all_events_mask) * sizeof(uint32_t); 2230 xcb_parts[xcb_parts_idx].iov_len = xcb_popcount(_aux->all_events_mask) * sizeof(uint32_t); 2231 xcb_parts_idx++; 2232 xcb_align_to = ALIGNOF(uint32_t); 2233 /* insert padding */ 2234 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2235 xcb_buffer_len += xcb_block_len + xcb_pad; 2236 if (0 != xcb_pad) { 2237 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 2238 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 2239 xcb_parts_idx++; 2240 xcb_pad = 0; 2241 } 2242 xcb_block_len = 0; 2243 2244 if (NULL == xcb_out) { 2245 /* allocate memory */ 2246 xcb_out = malloc(xcb_buffer_len); 2247 *_buffer = xcb_out; 2248 } 2249 2250 xcb_tmp = xcb_out; 2251 for(i=0; i<xcb_parts_idx; i++) { 2252 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 2253 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 2254 if (0 != xcb_parts[i].iov_len) 2255 xcb_tmp += xcb_parts[i].iov_len; 2256 } 2257 2258 return xcb_buffer_len; 2259 } 2260 2261 int 2262 xcb_x_print_print_input_selected_unserialize (const void *_buffer /**< */, 2263 xcb_x_print_print_input_selected_reply_t **_aux /**< */) 2264 { 2265 char *xcb_tmp = (char *)_buffer; 2266 xcb_x_print_print_input_selected_reply_t xcb_out; 2267 unsigned int xcb_buffer_len = 0; 2268 unsigned int xcb_block_len = 0; 2269 unsigned int xcb_pad = 0; 2270 unsigned int xcb_align_to; 2271 2272 uint32_t *event_list; 2273 int event_list_len; 2274 uint32_t *all_events_list; 2275 int all_events_list_len; 2276 2277 /* xcb_x_print_print_input_selected_reply_t.response_type */ 2278 xcb_out.response_type = *(uint8_t *)xcb_tmp; 2279 xcb_block_len += sizeof(uint8_t); 2280 xcb_tmp += sizeof(uint8_t); 2281 xcb_align_to = ALIGNOF(uint8_t); 2282 /* xcb_x_print_print_input_selected_reply_t.pad0 */ 2283 xcb_out.pad0 = *(uint8_t *)xcb_tmp; 2284 xcb_block_len += sizeof(uint8_t); 2285 xcb_tmp += sizeof(uint8_t); 2286 xcb_align_to = ALIGNOF(uint8_t); 2287 /* xcb_x_print_print_input_selected_reply_t.sequence */ 2288 xcb_out.sequence = *(uint16_t *)xcb_tmp; 2289 xcb_block_len += sizeof(uint16_t); 2290 xcb_tmp += sizeof(uint16_t); 2291 xcb_align_to = ALIGNOF(uint16_t); 2292 /* xcb_x_print_print_input_selected_reply_t.length */ 2293 xcb_out.length = *(uint32_t *)xcb_tmp; 2294 xcb_block_len += sizeof(uint32_t); 2295 xcb_tmp += sizeof(uint32_t); 2296 xcb_align_to = ALIGNOF(uint32_t); 2297 /* xcb_x_print_print_input_selected_reply_t.event_mask */ 2298 xcb_out.event_mask = *(uint32_t *)xcb_tmp; 2299 xcb_block_len += sizeof(uint32_t); 2300 xcb_tmp += sizeof(uint32_t); 2301 xcb_align_to = ALIGNOF(uint32_t); 2302 /* event_list */ 2303 event_list = (uint32_t *)xcb_tmp; 2304 event_list_len = xcb_popcount(xcb_out.event_mask) * sizeof(uint32_t); 2305 xcb_block_len += event_list_len; 2306 xcb_tmp += event_list_len; 2307 xcb_align_to = ALIGNOF(uint32_t); 2308 /* xcb_x_print_print_input_selected_reply_t.all_events_mask */ 2309 xcb_out.all_events_mask = *(uint32_t *)xcb_tmp; 2310 xcb_block_len += sizeof(uint32_t); 2311 xcb_tmp += sizeof(uint32_t); 2312 xcb_align_to = ALIGNOF(uint32_t); 2313 /* all_events_list */ 2314 all_events_list = (uint32_t *)xcb_tmp; 2315 all_events_list_len = xcb_popcount(xcb_out.all_events_mask) * sizeof(uint32_t); 2316 xcb_block_len += all_events_list_len; 2317 xcb_tmp += all_events_list_len; 2318 xcb_align_to = ALIGNOF(uint32_t); 2319 /* insert padding */ 2320 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2321 xcb_buffer_len += xcb_block_len + xcb_pad; 2322 if (0 != xcb_pad) { 2323 xcb_tmp += xcb_pad; 2324 xcb_pad = 0; 2325 } 2326 xcb_block_len = 0; 2327 2328 if (NULL == _aux) 2329 return xcb_buffer_len; 2330 2331 if (NULL == *_aux) { 2332 /* allocate memory */ 2333 *_aux = malloc(xcb_buffer_len); 2334 } 2335 2336 xcb_tmp = ((char *)*_aux)+xcb_buffer_len; 2337 xcb_tmp -= all_events_list_len; 2338 memmove(xcb_tmp, all_events_list, all_events_list_len); 2339 xcb_tmp -= event_list_len; 2340 memmove(xcb_tmp, event_list, event_list_len); 2341 **_aux = xcb_out; 2342 2343 return xcb_buffer_len; 2344 } 2345 2346 int 2347 xcb_x_print_print_input_selected_sizeof (const void *_buffer /**< */) 2348 { 2349 return xcb_x_print_print_input_selected_unserialize(_buffer, NULL); 2350 } 2351 2352 2353 /***************************************************************************** 2354 ** 2355 ** xcb_x_print_print_input_selected_cookie_t xcb_x_print_print_input_selected 2356 ** 2357 ** @param xcb_connection_t *c 2358 ** @param xcb_x_print_pcontext_t context 2359 ** @returns xcb_x_print_print_input_selected_cookie_t 2360 ** 2361 *****************************************************************************/ 2362 2363 xcb_x_print_print_input_selected_cookie_t 2364 xcb_x_print_print_input_selected (xcb_connection_t *c /**< */, 2365 xcb_x_print_pcontext_t context /**< */) 2366 { 2367 static const xcb_protocol_request_t xcb_req = { 2368 /* count */ 2, 2369 /* ext */ &xcb_x_print_id, 2370 /* opcode */ XCB_X_PRINT_PRINT_INPUT_SELECTED, 2371 /* isvoid */ 0 2372 }; 2373 2374 struct iovec xcb_parts[4]; 2375 xcb_x_print_print_input_selected_cookie_t xcb_ret; 2376 xcb_x_print_print_input_selected_request_t xcb_out; 2377 2378 xcb_out.context = context; 2379 2380 xcb_parts[2].iov_base = (char *) &xcb_out; 2381 xcb_parts[2].iov_len = sizeof(xcb_out); 2382 xcb_parts[3].iov_base = 0; 2383 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2384 2385 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2386 return xcb_ret; 2387 } 2388 2389 2390 /***************************************************************************** 2391 ** 2392 ** xcb_x_print_print_input_selected_cookie_t xcb_x_print_print_input_selected_unchecked 2393 ** 2394 ** @param xcb_connection_t *c 2395 ** @param xcb_x_print_pcontext_t context 2396 ** @returns xcb_x_print_print_input_selected_cookie_t 2397 ** 2398 *****************************************************************************/ 2399 2400 xcb_x_print_print_input_selected_cookie_t 2401 xcb_x_print_print_input_selected_unchecked (xcb_connection_t *c /**< */, 2402 xcb_x_print_pcontext_t context /**< */) 2403 { 2404 static const xcb_protocol_request_t xcb_req = { 2405 /* count */ 2, 2406 /* ext */ &xcb_x_print_id, 2407 /* opcode */ XCB_X_PRINT_PRINT_INPUT_SELECTED, 2408 /* isvoid */ 0 2409 }; 2410 2411 struct iovec xcb_parts[4]; 2412 xcb_x_print_print_input_selected_cookie_t xcb_ret; 2413 xcb_x_print_print_input_selected_request_t xcb_out; 2414 2415 xcb_out.context = context; 2416 2417 xcb_parts[2].iov_base = (char *) &xcb_out; 2418 xcb_parts[2].iov_len = sizeof(xcb_out); 2419 xcb_parts[3].iov_base = 0; 2420 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2421 2422 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2423 return xcb_ret; 2424 } 2425 2426 2427 /***************************************************************************** 2428 ** 2429 ** uint32_t * xcb_x_print_print_input_selected_event_list 2430 ** 2431 ** @param const xcb_x_print_print_input_selected_reply_t *R 2432 ** @returns uint32_t * 2433 ** 2434 *****************************************************************************/ 2435 2436 uint32_t * 2437 xcb_x_print_print_input_selected_event_list (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2438 { 2439 return (uint32_t *) (R + 1); 2440 } 2441 2442 2443 /***************************************************************************** 2444 ** 2445 ** int xcb_x_print_print_input_selected_event_list_length 2446 ** 2447 ** @param const xcb_x_print_print_input_selected_reply_t *R 2448 ** @returns int 2449 ** 2450 *****************************************************************************/ 2451 2452 int 2453 xcb_x_print_print_input_selected_event_list_length (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2454 { 2455 return xcb_popcount(R->event_mask); 2456 } 2457 2458 2459 /***************************************************************************** 2460 ** 2461 ** xcb_generic_iterator_t xcb_x_print_print_input_selected_event_list_end 2462 ** 2463 ** @param const xcb_x_print_print_input_selected_reply_t *R 2464 ** @returns xcb_generic_iterator_t 2465 ** 2466 *****************************************************************************/ 2467 2468 xcb_generic_iterator_t 2469 xcb_x_print_print_input_selected_event_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2470 { 2471 xcb_generic_iterator_t i; 2472 i.data = ((uint32_t *) (R + 1)) + (xcb_popcount(R->event_mask)); 2473 i.rem = 0; 2474 i.index = (char *) i.data - (char *) R; 2475 return i; 2476 } 2477 2478 2479 /***************************************************************************** 2480 ** 2481 ** uint32_t * xcb_x_print_print_input_selected_all_events_list 2482 ** 2483 ** @param const xcb_x_print_print_input_selected_reply_t *R 2484 ** @returns uint32_t * 2485 ** 2486 *****************************************************************************/ 2487 2488 uint32_t * 2489 xcb_x_print_print_input_selected_all_events_list (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2490 { 2491 xcb_generic_iterator_t prev = xcb_x_print_print_input_selected_event_list_end(R); 2492 return (uint32_t *) ((char *) prev.data + XCB_TYPE_PAD(uint32_t, prev.index) + 4); 2493 } 2494 2495 2496 /***************************************************************************** 2497 ** 2498 ** int xcb_x_print_print_input_selected_all_events_list_length 2499 ** 2500 ** @param const xcb_x_print_print_input_selected_reply_t *R 2501 ** @returns int 2502 ** 2503 *****************************************************************************/ 2504 2505 int 2506 xcb_x_print_print_input_selected_all_events_list_length (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2507 { 2508 return xcb_popcount(R->all_events_mask); 2509 } 2510 2511 2512 /***************************************************************************** 2513 ** 2514 ** xcb_generic_iterator_t xcb_x_print_print_input_selected_all_events_list_end 2515 ** 2516 ** @param const xcb_x_print_print_input_selected_reply_t *R 2517 ** @returns xcb_generic_iterator_t 2518 ** 2519 *****************************************************************************/ 2520 2521 xcb_generic_iterator_t 2522 xcb_x_print_print_input_selected_all_events_list_end (const xcb_x_print_print_input_selected_reply_t *R /**< */) 2523 { 2524 xcb_generic_iterator_t i; 2525 xcb_generic_iterator_t child = xcb_x_print_print_input_selected_event_list_end(R); 2526 i.data = ((uint32_t *) child.data) + (xcb_popcount(R->all_events_mask)); 2527 i.rem = 0; 2528 i.index = (char *) i.data - (char *) R; 2529 return i; 2530 } 2531 2532 2533 /***************************************************************************** 2534 ** 2535 ** xcb_x_print_print_input_selected_reply_t * xcb_x_print_print_input_selected_reply 2536 ** 2537 ** @param xcb_connection_t *c 2538 ** @param xcb_x_print_print_input_selected_cookie_t cookie 2539 ** @param xcb_generic_error_t **e 2540 ** @returns xcb_x_print_print_input_selected_reply_t * 2541 ** 2542 *****************************************************************************/ 2543 2544 xcb_x_print_print_input_selected_reply_t * 2545 xcb_x_print_print_input_selected_reply (xcb_connection_t *c /**< */, 2546 xcb_x_print_print_input_selected_cookie_t cookie /**< */, 2547 xcb_generic_error_t **e /**< */) 2548 { 2549 return (xcb_x_print_print_input_selected_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2550 } 2551 2552 2553 /***************************************************************************** 2554 ** 2555 ** xcb_x_print_print_get_attributes_cookie_t xcb_x_print_print_get_attributes 2556 ** 2557 ** @param xcb_connection_t *c 2558 ** @param xcb_x_print_pcontext_t context 2559 ** @param uint8_t pool 2560 ** @returns xcb_x_print_print_get_attributes_cookie_t 2561 ** 2562 *****************************************************************************/ 2563 2564 xcb_x_print_print_get_attributes_cookie_t 2565 xcb_x_print_print_get_attributes (xcb_connection_t *c /**< */, 2566 xcb_x_print_pcontext_t context /**< */, 2567 uint8_t pool /**< */) 2568 { 2569 static const xcb_protocol_request_t xcb_req = { 2570 /* count */ 2, 2571 /* ext */ &xcb_x_print_id, 2572 /* opcode */ XCB_X_PRINT_PRINT_GET_ATTRIBUTES, 2573 /* isvoid */ 0 2574 }; 2575 2576 struct iovec xcb_parts[4]; 2577 xcb_x_print_print_get_attributes_cookie_t xcb_ret; 2578 xcb_x_print_print_get_attributes_request_t xcb_out; 2579 2580 xcb_out.context = context; 2581 xcb_out.pool = pool; 2582 memset(xcb_out.pad0, 0, 3); 2583 2584 xcb_parts[2].iov_base = (char *) &xcb_out; 2585 xcb_parts[2].iov_len = sizeof(xcb_out); 2586 xcb_parts[3].iov_base = 0; 2587 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2588 2589 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2590 return xcb_ret; 2591 } 2592 2593 2594 /***************************************************************************** 2595 ** 2596 ** xcb_x_print_print_get_attributes_cookie_t xcb_x_print_print_get_attributes_unchecked 2597 ** 2598 ** @param xcb_connection_t *c 2599 ** @param xcb_x_print_pcontext_t context 2600 ** @param uint8_t pool 2601 ** @returns xcb_x_print_print_get_attributes_cookie_t 2602 ** 2603 *****************************************************************************/ 2604 2605 xcb_x_print_print_get_attributes_cookie_t 2606 xcb_x_print_print_get_attributes_unchecked (xcb_connection_t *c /**< */, 2607 xcb_x_print_pcontext_t context /**< */, 2608 uint8_t pool /**< */) 2609 { 2610 static const xcb_protocol_request_t xcb_req = { 2611 /* count */ 2, 2612 /* ext */ &xcb_x_print_id, 2613 /* opcode */ XCB_X_PRINT_PRINT_GET_ATTRIBUTES, 2614 /* isvoid */ 0 2615 }; 2616 2617 struct iovec xcb_parts[4]; 2618 xcb_x_print_print_get_attributes_cookie_t xcb_ret; 2619 xcb_x_print_print_get_attributes_request_t xcb_out; 2620 2621 xcb_out.context = context; 2622 xcb_out.pool = pool; 2623 memset(xcb_out.pad0, 0, 3); 2624 2625 xcb_parts[2].iov_base = (char *) &xcb_out; 2626 xcb_parts[2].iov_len = sizeof(xcb_out); 2627 xcb_parts[3].iov_base = 0; 2628 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2629 2630 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2631 return xcb_ret; 2632 } 2633 2634 2635 /***************************************************************************** 2636 ** 2637 ** xcb_x_print_print_get_attributes_reply_t * xcb_x_print_print_get_attributes_reply 2638 ** 2639 ** @param xcb_connection_t *c 2640 ** @param xcb_x_print_print_get_attributes_cookie_t cookie 2641 ** @param xcb_generic_error_t **e 2642 ** @returns xcb_x_print_print_get_attributes_reply_t * 2643 ** 2644 *****************************************************************************/ 2645 2646 xcb_x_print_print_get_attributes_reply_t * 2647 xcb_x_print_print_get_attributes_reply (xcb_connection_t *c /**< */, 2648 xcb_x_print_print_get_attributes_cookie_t cookie /**< */, 2649 xcb_generic_error_t **e /**< */) 2650 { 2651 return (xcb_x_print_print_get_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2652 } 2653 2654 int 2655 xcb_x_print_print_get_one_attributes_sizeof (const void *_buffer /**< */) 2656 { 2657 char *xcb_tmp = (char *)_buffer; 2658 const xcb_x_print_print_get_one_attributes_request_t *_aux = (xcb_x_print_print_get_one_attributes_request_t *)_buffer; 2659 unsigned int xcb_buffer_len = 0; 2660 unsigned int xcb_block_len = 0; 2661 unsigned int xcb_pad = 0; 2662 unsigned int xcb_align_to; 2663 2664 2665 xcb_block_len += sizeof(xcb_x_print_print_get_one_attributes_request_t); 2666 xcb_tmp += xcb_block_len; 2667 /* name */ 2668 xcb_block_len += _aux->nameLen * sizeof(xcb_x_print_string8_t); 2669 xcb_tmp += xcb_block_len; 2670 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 2671 /* insert padding */ 2672 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2673 xcb_buffer_len += xcb_block_len + xcb_pad; 2674 if (0 != xcb_pad) { 2675 xcb_tmp += xcb_pad; 2676 xcb_pad = 0; 2677 } 2678 xcb_block_len = 0; 2679 2680 return xcb_buffer_len; 2681 } 2682 2683 2684 /***************************************************************************** 2685 ** 2686 ** xcb_x_print_print_get_one_attributes_cookie_t xcb_x_print_print_get_one_attributes 2687 ** 2688 ** @param xcb_connection_t *c 2689 ** @param xcb_x_print_pcontext_t context 2690 ** @param uint32_t nameLen 2691 ** @param uint8_t pool 2692 ** @param const xcb_x_print_string8_t *name 2693 ** @returns xcb_x_print_print_get_one_attributes_cookie_t 2694 ** 2695 *****************************************************************************/ 2696 2697 xcb_x_print_print_get_one_attributes_cookie_t 2698 xcb_x_print_print_get_one_attributes (xcb_connection_t *c /**< */, 2699 xcb_x_print_pcontext_t context /**< */, 2700 uint32_t nameLen /**< */, 2701 uint8_t pool /**< */, 2702 const xcb_x_print_string8_t *name /**< */) 2703 { 2704 static const xcb_protocol_request_t xcb_req = { 2705 /* count */ 4, 2706 /* ext */ &xcb_x_print_id, 2707 /* opcode */ XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, 2708 /* isvoid */ 0 2709 }; 2710 2711 struct iovec xcb_parts[6]; 2712 xcb_x_print_print_get_one_attributes_cookie_t xcb_ret; 2713 xcb_x_print_print_get_one_attributes_request_t xcb_out; 2714 2715 xcb_out.context = context; 2716 xcb_out.nameLen = nameLen; 2717 xcb_out.pool = pool; 2718 memset(xcb_out.pad0, 0, 3); 2719 2720 xcb_parts[2].iov_base = (char *) &xcb_out; 2721 xcb_parts[2].iov_len = sizeof(xcb_out); 2722 xcb_parts[3].iov_base = 0; 2723 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2724 /* xcb_x_print_string8_t name */ 2725 xcb_parts[4].iov_base = (char *) name; 2726 xcb_parts[4].iov_len = nameLen * sizeof(xcb_x_print_string8_t); 2727 xcb_parts[5].iov_base = 0; 2728 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2729 2730 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2731 return xcb_ret; 2732 } 2733 2734 2735 /***************************************************************************** 2736 ** 2737 ** xcb_x_print_print_get_one_attributes_cookie_t xcb_x_print_print_get_one_attributes_unchecked 2738 ** 2739 ** @param xcb_connection_t *c 2740 ** @param xcb_x_print_pcontext_t context 2741 ** @param uint32_t nameLen 2742 ** @param uint8_t pool 2743 ** @param const xcb_x_print_string8_t *name 2744 ** @returns xcb_x_print_print_get_one_attributes_cookie_t 2745 ** 2746 *****************************************************************************/ 2747 2748 xcb_x_print_print_get_one_attributes_cookie_t 2749 xcb_x_print_print_get_one_attributes_unchecked (xcb_connection_t *c /**< */, 2750 xcb_x_print_pcontext_t context /**< */, 2751 uint32_t nameLen /**< */, 2752 uint8_t pool /**< */, 2753 const xcb_x_print_string8_t *name /**< */) 2754 { 2755 static const xcb_protocol_request_t xcb_req = { 2756 /* count */ 4, 2757 /* ext */ &xcb_x_print_id, 2758 /* opcode */ XCB_X_PRINT_PRINT_GET_ONE_ATTRIBUTES, 2759 /* isvoid */ 0 2760 }; 2761 2762 struct iovec xcb_parts[6]; 2763 xcb_x_print_print_get_one_attributes_cookie_t xcb_ret; 2764 xcb_x_print_print_get_one_attributes_request_t xcb_out; 2765 2766 xcb_out.context = context; 2767 xcb_out.nameLen = nameLen; 2768 xcb_out.pool = pool; 2769 memset(xcb_out.pad0, 0, 3); 2770 2771 xcb_parts[2].iov_base = (char *) &xcb_out; 2772 xcb_parts[2].iov_len = sizeof(xcb_out); 2773 xcb_parts[3].iov_base = 0; 2774 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2775 /* xcb_x_print_string8_t name */ 2776 xcb_parts[4].iov_base = (char *) name; 2777 xcb_parts[4].iov_len = nameLen * sizeof(xcb_x_print_string8_t); 2778 xcb_parts[5].iov_base = 0; 2779 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2780 2781 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2782 return xcb_ret; 2783 } 2784 2785 2786 /***************************************************************************** 2787 ** 2788 ** xcb_x_print_string8_t * xcb_x_print_print_get_one_attributes_value 2789 ** 2790 ** @param const xcb_x_print_print_get_one_attributes_reply_t *R 2791 ** @returns xcb_x_print_string8_t * 2792 ** 2793 *****************************************************************************/ 2794 2795 xcb_x_print_string8_t * 2796 xcb_x_print_print_get_one_attributes_value (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) 2797 { 2798 return (xcb_x_print_string8_t *) (R + 1); 2799 } 2800 2801 2802 /***************************************************************************** 2803 ** 2804 ** int xcb_x_print_print_get_one_attributes_value_length 2805 ** 2806 ** @param const xcb_x_print_print_get_one_attributes_reply_t *R 2807 ** @returns int 2808 ** 2809 *****************************************************************************/ 2810 2811 int 2812 xcb_x_print_print_get_one_attributes_value_length (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) 2813 { 2814 return R->valueLen; 2815 } 2816 2817 2818 /***************************************************************************** 2819 ** 2820 ** xcb_generic_iterator_t xcb_x_print_print_get_one_attributes_value_end 2821 ** 2822 ** @param const xcb_x_print_print_get_one_attributes_reply_t *R 2823 ** @returns xcb_generic_iterator_t 2824 ** 2825 *****************************************************************************/ 2826 2827 xcb_generic_iterator_t 2828 xcb_x_print_print_get_one_attributes_value_end (const xcb_x_print_print_get_one_attributes_reply_t *R /**< */) 2829 { 2830 xcb_generic_iterator_t i; 2831 i.data = ((xcb_x_print_string8_t *) (R + 1)) + (R->valueLen); 2832 i.rem = 0; 2833 i.index = (char *) i.data - (char *) R; 2834 return i; 2835 } 2836 2837 2838 /***************************************************************************** 2839 ** 2840 ** xcb_x_print_print_get_one_attributes_reply_t * xcb_x_print_print_get_one_attributes_reply 2841 ** 2842 ** @param xcb_connection_t *c 2843 ** @param xcb_x_print_print_get_one_attributes_cookie_t cookie 2844 ** @param xcb_generic_error_t **e 2845 ** @returns xcb_x_print_print_get_one_attributes_reply_t * 2846 ** 2847 *****************************************************************************/ 2848 2849 xcb_x_print_print_get_one_attributes_reply_t * 2850 xcb_x_print_print_get_one_attributes_reply (xcb_connection_t *c /**< */, 2851 xcb_x_print_print_get_one_attributes_cookie_t cookie /**< */, 2852 xcb_generic_error_t **e /**< */) 2853 { 2854 return (xcb_x_print_print_get_one_attributes_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 2855 } 2856 2857 int 2858 xcb_x_print_print_set_attributes_sizeof (const void *_buffer /**< */, 2859 uint32_t attributes_len /**< */) 2860 { 2861 char *xcb_tmp = (char *)_buffer; 2862 unsigned int xcb_buffer_len = 0; 2863 unsigned int xcb_block_len = 0; 2864 unsigned int xcb_pad = 0; 2865 unsigned int xcb_align_to; 2866 2867 2868 xcb_block_len += sizeof(xcb_x_print_print_set_attributes_request_t); 2869 xcb_tmp += xcb_block_len; 2870 /* attributes */ 2871 xcb_block_len += attributes_len * sizeof(xcb_x_print_string8_t); 2872 xcb_tmp += xcb_block_len; 2873 xcb_align_to = ALIGNOF(xcb_x_print_string8_t); 2874 /* insert padding */ 2875 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 2876 xcb_buffer_len += xcb_block_len + xcb_pad; 2877 if (0 != xcb_pad) { 2878 xcb_tmp += xcb_pad; 2879 xcb_pad = 0; 2880 } 2881 xcb_block_len = 0; 2882 2883 return xcb_buffer_len; 2884 } 2885 2886 2887 /***************************************************************************** 2888 ** 2889 ** xcb_void_cookie_t xcb_x_print_print_set_attributes_checked 2890 ** 2891 ** @param xcb_connection_t *c 2892 ** @param xcb_x_print_pcontext_t context 2893 ** @param uint32_t stringLen 2894 ** @param uint8_t pool 2895 ** @param uint8_t rule 2896 ** @param uint32_t attributes_len 2897 ** @param const xcb_x_print_string8_t *attributes 2898 ** @returns xcb_void_cookie_t 2899 ** 2900 *****************************************************************************/ 2901 2902 xcb_void_cookie_t 2903 xcb_x_print_print_set_attributes_checked (xcb_connection_t *c /**< */, 2904 xcb_x_print_pcontext_t context /**< */, 2905 uint32_t stringLen /**< */, 2906 uint8_t pool /**< */, 2907 uint8_t rule /**< */, 2908 uint32_t attributes_len /**< */, 2909 const xcb_x_print_string8_t *attributes /**< */) 2910 { 2911 static const xcb_protocol_request_t xcb_req = { 2912 /* count */ 4, 2913 /* ext */ &xcb_x_print_id, 2914 /* opcode */ XCB_X_PRINT_PRINT_SET_ATTRIBUTES, 2915 /* isvoid */ 1 2916 }; 2917 2918 struct iovec xcb_parts[6]; 2919 xcb_void_cookie_t xcb_ret; 2920 xcb_x_print_print_set_attributes_request_t xcb_out; 2921 2922 xcb_out.context = context; 2923 xcb_out.stringLen = stringLen; 2924 xcb_out.pool = pool; 2925 xcb_out.rule = rule; 2926 memset(xcb_out.pad0, 0, 2); 2927 2928 xcb_parts[2].iov_base = (char *) &xcb_out; 2929 xcb_parts[2].iov_len = sizeof(xcb_out); 2930 xcb_parts[3].iov_base = 0; 2931 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2932 /* xcb_x_print_string8_t attributes */ 2933 xcb_parts[4].iov_base = (char *) attributes; 2934 xcb_parts[4].iov_len = attributes_len * sizeof(xcb_x_print_string8_t); 2935 xcb_parts[5].iov_base = 0; 2936 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2937 2938 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 2939 return xcb_ret; 2940 } 2941 2942 2943 /***************************************************************************** 2944 ** 2945 ** xcb_void_cookie_t xcb_x_print_print_set_attributes 2946 ** 2947 ** @param xcb_connection_t *c 2948 ** @param xcb_x_print_pcontext_t context 2949 ** @param uint32_t stringLen 2950 ** @param uint8_t pool 2951 ** @param uint8_t rule 2952 ** @param uint32_t attributes_len 2953 ** @param const xcb_x_print_string8_t *attributes 2954 ** @returns xcb_void_cookie_t 2955 ** 2956 *****************************************************************************/ 2957 2958 xcb_void_cookie_t 2959 xcb_x_print_print_set_attributes (xcb_connection_t *c /**< */, 2960 xcb_x_print_pcontext_t context /**< */, 2961 uint32_t stringLen /**< */, 2962 uint8_t pool /**< */, 2963 uint8_t rule /**< */, 2964 uint32_t attributes_len /**< */, 2965 const xcb_x_print_string8_t *attributes /**< */) 2966 { 2967 static const xcb_protocol_request_t xcb_req = { 2968 /* count */ 4, 2969 /* ext */ &xcb_x_print_id, 2970 /* opcode */ XCB_X_PRINT_PRINT_SET_ATTRIBUTES, 2971 /* isvoid */ 1 2972 }; 2973 2974 struct iovec xcb_parts[6]; 2975 xcb_void_cookie_t xcb_ret; 2976 xcb_x_print_print_set_attributes_request_t xcb_out; 2977 2978 xcb_out.context = context; 2979 xcb_out.stringLen = stringLen; 2980 xcb_out.pool = pool; 2981 xcb_out.rule = rule; 2982 memset(xcb_out.pad0, 0, 2); 2983 2984 xcb_parts[2].iov_base = (char *) &xcb_out; 2985 xcb_parts[2].iov_len = sizeof(xcb_out); 2986 xcb_parts[3].iov_base = 0; 2987 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 2988 /* xcb_x_print_string8_t attributes */ 2989 xcb_parts[4].iov_base = (char *) attributes; 2990 xcb_parts[4].iov_len = attributes_len * sizeof(xcb_x_print_string8_t); 2991 xcb_parts[5].iov_base = 0; 2992 xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; 2993 2994 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 2995 return xcb_ret; 2996 } 2997 2998 2999 /***************************************************************************** 3000 ** 3001 ** xcb_x_print_print_get_page_dimensions_cookie_t xcb_x_print_print_get_page_dimensions 3002 ** 3003 ** @param xcb_connection_t *c 3004 ** @param xcb_x_print_pcontext_t context 3005 ** @returns xcb_x_print_print_get_page_dimensions_cookie_t 3006 ** 3007 *****************************************************************************/ 3008 3009 xcb_x_print_print_get_page_dimensions_cookie_t 3010 xcb_x_print_print_get_page_dimensions (xcb_connection_t *c /**< */, 3011 xcb_x_print_pcontext_t context /**< */) 3012 { 3013 static const xcb_protocol_request_t xcb_req = { 3014 /* count */ 2, 3015 /* ext */ &xcb_x_print_id, 3016 /* opcode */ XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, 3017 /* isvoid */ 0 3018 }; 3019 3020 struct iovec xcb_parts[4]; 3021 xcb_x_print_print_get_page_dimensions_cookie_t xcb_ret; 3022 xcb_x_print_print_get_page_dimensions_request_t xcb_out; 3023 3024 xcb_out.context = context; 3025 3026 xcb_parts[2].iov_base = (char *) &xcb_out; 3027 xcb_parts[2].iov_len = sizeof(xcb_out); 3028 xcb_parts[3].iov_base = 0; 3029 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3030 3031 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3032 return xcb_ret; 3033 } 3034 3035 3036 /***************************************************************************** 3037 ** 3038 ** xcb_x_print_print_get_page_dimensions_cookie_t xcb_x_print_print_get_page_dimensions_unchecked 3039 ** 3040 ** @param xcb_connection_t *c 3041 ** @param xcb_x_print_pcontext_t context 3042 ** @returns xcb_x_print_print_get_page_dimensions_cookie_t 3043 ** 3044 *****************************************************************************/ 3045 3046 xcb_x_print_print_get_page_dimensions_cookie_t 3047 xcb_x_print_print_get_page_dimensions_unchecked (xcb_connection_t *c /**< */, 3048 xcb_x_print_pcontext_t context /**< */) 3049 { 3050 static const xcb_protocol_request_t xcb_req = { 3051 /* count */ 2, 3052 /* ext */ &xcb_x_print_id, 3053 /* opcode */ XCB_X_PRINT_PRINT_GET_PAGE_DIMENSIONS, 3054 /* isvoid */ 0 3055 }; 3056 3057 struct iovec xcb_parts[4]; 3058 xcb_x_print_print_get_page_dimensions_cookie_t xcb_ret; 3059 xcb_x_print_print_get_page_dimensions_request_t xcb_out; 3060 3061 xcb_out.context = context; 3062 3063 xcb_parts[2].iov_base = (char *) &xcb_out; 3064 xcb_parts[2].iov_len = sizeof(xcb_out); 3065 xcb_parts[3].iov_base = 0; 3066 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3067 3068 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3069 return xcb_ret; 3070 } 3071 3072 3073 /***************************************************************************** 3074 ** 3075 ** xcb_x_print_print_get_page_dimensions_reply_t * xcb_x_print_print_get_page_dimensions_reply 3076 ** 3077 ** @param xcb_connection_t *c 3078 ** @param xcb_x_print_print_get_page_dimensions_cookie_t cookie 3079 ** @param xcb_generic_error_t **e 3080 ** @returns xcb_x_print_print_get_page_dimensions_reply_t * 3081 ** 3082 *****************************************************************************/ 3083 3084 xcb_x_print_print_get_page_dimensions_reply_t * 3085 xcb_x_print_print_get_page_dimensions_reply (xcb_connection_t *c /**< */, 3086 xcb_x_print_print_get_page_dimensions_cookie_t cookie /**< */, 3087 xcb_generic_error_t **e /**< */) 3088 { 3089 return (xcb_x_print_print_get_page_dimensions_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3090 } 3091 3092 int 3093 xcb_x_print_print_query_screens_sizeof (const void *_buffer /**< */) 3094 { 3095 char *xcb_tmp = (char *)_buffer; 3096 const xcb_x_print_print_query_screens_reply_t *_aux = (xcb_x_print_print_query_screens_reply_t *)_buffer; 3097 unsigned int xcb_buffer_len = 0; 3098 unsigned int xcb_block_len = 0; 3099 unsigned int xcb_pad = 0; 3100 unsigned int xcb_align_to; 3101 3102 3103 xcb_block_len += sizeof(xcb_x_print_print_query_screens_reply_t); 3104 xcb_tmp += xcb_block_len; 3105 /* roots */ 3106 xcb_block_len += _aux->listCount * sizeof(xcb_window_t); 3107 xcb_tmp += xcb_block_len; 3108 xcb_align_to = ALIGNOF(xcb_window_t); 3109 /* insert padding */ 3110 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 3111 xcb_buffer_len += xcb_block_len + xcb_pad; 3112 if (0 != xcb_pad) { 3113 xcb_tmp += xcb_pad; 3114 xcb_pad = 0; 3115 } 3116 xcb_block_len = 0; 3117 3118 return xcb_buffer_len; 3119 } 3120 3121 3122 /***************************************************************************** 3123 ** 3124 ** xcb_x_print_print_query_screens_cookie_t xcb_x_print_print_query_screens 3125 ** 3126 ** @param xcb_connection_t *c 3127 ** @returns xcb_x_print_print_query_screens_cookie_t 3128 ** 3129 *****************************************************************************/ 3130 3131 xcb_x_print_print_query_screens_cookie_t 3132 xcb_x_print_print_query_screens (xcb_connection_t *c /**< */) 3133 { 3134 static const xcb_protocol_request_t xcb_req = { 3135 /* count */ 2, 3136 /* ext */ &xcb_x_print_id, 3137 /* opcode */ XCB_X_PRINT_PRINT_QUERY_SCREENS, 3138 /* isvoid */ 0 3139 }; 3140 3141 struct iovec xcb_parts[4]; 3142 xcb_x_print_print_query_screens_cookie_t xcb_ret; 3143 xcb_x_print_print_query_screens_request_t xcb_out; 3144 3145 3146 xcb_parts[2].iov_base = (char *) &xcb_out; 3147 xcb_parts[2].iov_len = sizeof(xcb_out); 3148 xcb_parts[3].iov_base = 0; 3149 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3150 3151 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3152 return xcb_ret; 3153 } 3154 3155 3156 /***************************************************************************** 3157 ** 3158 ** xcb_x_print_print_query_screens_cookie_t xcb_x_print_print_query_screens_unchecked 3159 ** 3160 ** @param xcb_connection_t *c 3161 ** @returns xcb_x_print_print_query_screens_cookie_t 3162 ** 3163 *****************************************************************************/ 3164 3165 xcb_x_print_print_query_screens_cookie_t 3166 xcb_x_print_print_query_screens_unchecked (xcb_connection_t *c /**< */) 3167 { 3168 static const xcb_protocol_request_t xcb_req = { 3169 /* count */ 2, 3170 /* ext */ &xcb_x_print_id, 3171 /* opcode */ XCB_X_PRINT_PRINT_QUERY_SCREENS, 3172 /* isvoid */ 0 3173 }; 3174 3175 struct iovec xcb_parts[4]; 3176 xcb_x_print_print_query_screens_cookie_t xcb_ret; 3177 xcb_x_print_print_query_screens_request_t xcb_out; 3178 3179 3180 xcb_parts[2].iov_base = (char *) &xcb_out; 3181 xcb_parts[2].iov_len = sizeof(xcb_out); 3182 xcb_parts[3].iov_base = 0; 3183 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3184 3185 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3186 return xcb_ret; 3187 } 3188 3189 3190 /***************************************************************************** 3191 ** 3192 ** xcb_window_t * xcb_x_print_print_query_screens_roots 3193 ** 3194 ** @param const xcb_x_print_print_query_screens_reply_t *R 3195 ** @returns xcb_window_t * 3196 ** 3197 *****************************************************************************/ 3198 3199 xcb_window_t * 3200 xcb_x_print_print_query_screens_roots (const xcb_x_print_print_query_screens_reply_t *R /**< */) 3201 { 3202 return (xcb_window_t *) (R + 1); 3203 } 3204 3205 3206 /***************************************************************************** 3207 ** 3208 ** int xcb_x_print_print_query_screens_roots_length 3209 ** 3210 ** @param const xcb_x_print_print_query_screens_reply_t *R 3211 ** @returns int 3212 ** 3213 *****************************************************************************/ 3214 3215 int 3216 xcb_x_print_print_query_screens_roots_length (const xcb_x_print_print_query_screens_reply_t *R /**< */) 3217 { 3218 return R->listCount; 3219 } 3220 3221 3222 /***************************************************************************** 3223 ** 3224 ** xcb_generic_iterator_t xcb_x_print_print_query_screens_roots_end 3225 ** 3226 ** @param const xcb_x_print_print_query_screens_reply_t *R 3227 ** @returns xcb_generic_iterator_t 3228 ** 3229 *****************************************************************************/ 3230 3231 xcb_generic_iterator_t 3232 xcb_x_print_print_query_screens_roots_end (const xcb_x_print_print_query_screens_reply_t *R /**< */) 3233 { 3234 xcb_generic_iterator_t i; 3235 i.data = ((xcb_window_t *) (R + 1)) + (R->listCount); 3236 i.rem = 0; 3237 i.index = (char *) i.data - (char *) R; 3238 return i; 3239 } 3240 3241 3242 /***************************************************************************** 3243 ** 3244 ** xcb_x_print_print_query_screens_reply_t * xcb_x_print_print_query_screens_reply 3245 ** 3246 ** @param xcb_connection_t *c 3247 ** @param xcb_x_print_print_query_screens_cookie_t cookie 3248 ** @param xcb_generic_error_t **e 3249 ** @returns xcb_x_print_print_query_screens_reply_t * 3250 ** 3251 *****************************************************************************/ 3252 3253 xcb_x_print_print_query_screens_reply_t * 3254 xcb_x_print_print_query_screens_reply (xcb_connection_t *c /**< */, 3255 xcb_x_print_print_query_screens_cookie_t cookie /**< */, 3256 xcb_generic_error_t **e /**< */) 3257 { 3258 return (xcb_x_print_print_query_screens_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3259 } 3260 3261 3262 /***************************************************************************** 3263 ** 3264 ** xcb_x_print_print_set_image_resolution_cookie_t xcb_x_print_print_set_image_resolution 3265 ** 3266 ** @param xcb_connection_t *c 3267 ** @param xcb_x_print_pcontext_t context 3268 ** @param uint16_t image_resolution 3269 ** @returns xcb_x_print_print_set_image_resolution_cookie_t 3270 ** 3271 *****************************************************************************/ 3272 3273 xcb_x_print_print_set_image_resolution_cookie_t 3274 xcb_x_print_print_set_image_resolution (xcb_connection_t *c /**< */, 3275 xcb_x_print_pcontext_t context /**< */, 3276 uint16_t image_resolution /**< */) 3277 { 3278 static const xcb_protocol_request_t xcb_req = { 3279 /* count */ 2, 3280 /* ext */ &xcb_x_print_id, 3281 /* opcode */ XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, 3282 /* isvoid */ 0 3283 }; 3284 3285 struct iovec xcb_parts[4]; 3286 xcb_x_print_print_set_image_resolution_cookie_t xcb_ret; 3287 xcb_x_print_print_set_image_resolution_request_t xcb_out; 3288 3289 xcb_out.context = context; 3290 xcb_out.image_resolution = image_resolution; 3291 3292 xcb_parts[2].iov_base = (char *) &xcb_out; 3293 xcb_parts[2].iov_len = sizeof(xcb_out); 3294 xcb_parts[3].iov_base = 0; 3295 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3296 3297 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3298 return xcb_ret; 3299 } 3300 3301 3302 /***************************************************************************** 3303 ** 3304 ** xcb_x_print_print_set_image_resolution_cookie_t xcb_x_print_print_set_image_resolution_unchecked 3305 ** 3306 ** @param xcb_connection_t *c 3307 ** @param xcb_x_print_pcontext_t context 3308 ** @param uint16_t image_resolution 3309 ** @returns xcb_x_print_print_set_image_resolution_cookie_t 3310 ** 3311 *****************************************************************************/ 3312 3313 xcb_x_print_print_set_image_resolution_cookie_t 3314 xcb_x_print_print_set_image_resolution_unchecked (xcb_connection_t *c /**< */, 3315 xcb_x_print_pcontext_t context /**< */, 3316 uint16_t image_resolution /**< */) 3317 { 3318 static const xcb_protocol_request_t xcb_req = { 3319 /* count */ 2, 3320 /* ext */ &xcb_x_print_id, 3321 /* opcode */ XCB_X_PRINT_PRINT_SET_IMAGE_RESOLUTION, 3322 /* isvoid */ 0 3323 }; 3324 3325 struct iovec xcb_parts[4]; 3326 xcb_x_print_print_set_image_resolution_cookie_t xcb_ret; 3327 xcb_x_print_print_set_image_resolution_request_t xcb_out; 3328 3329 xcb_out.context = context; 3330 xcb_out.image_resolution = image_resolution; 3331 3332 xcb_parts[2].iov_base = (char *) &xcb_out; 3333 xcb_parts[2].iov_len = sizeof(xcb_out); 3334 xcb_parts[3].iov_base = 0; 3335 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3336 3337 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3338 return xcb_ret; 3339 } 3340 3341 3342 /***************************************************************************** 3343 ** 3344 ** xcb_x_print_print_set_image_resolution_reply_t * xcb_x_print_print_set_image_resolution_reply 3345 ** 3346 ** @param xcb_connection_t *c 3347 ** @param xcb_x_print_print_set_image_resolution_cookie_t cookie 3348 ** @param xcb_generic_error_t **e 3349 ** @returns xcb_x_print_print_set_image_resolution_reply_t * 3350 ** 3351 *****************************************************************************/ 3352 3353 xcb_x_print_print_set_image_resolution_reply_t * 3354 xcb_x_print_print_set_image_resolution_reply (xcb_connection_t *c /**< */, 3355 xcb_x_print_print_set_image_resolution_cookie_t cookie /**< */, 3356 xcb_generic_error_t **e /**< */) 3357 { 3358 return (xcb_x_print_print_set_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3359 } 3360 3361 3362 /***************************************************************************** 3363 ** 3364 ** xcb_x_print_print_get_image_resolution_cookie_t xcb_x_print_print_get_image_resolution 3365 ** 3366 ** @param xcb_connection_t *c 3367 ** @param xcb_x_print_pcontext_t context 3368 ** @returns xcb_x_print_print_get_image_resolution_cookie_t 3369 ** 3370 *****************************************************************************/ 3371 3372 xcb_x_print_print_get_image_resolution_cookie_t 3373 xcb_x_print_print_get_image_resolution (xcb_connection_t *c /**< */, 3374 xcb_x_print_pcontext_t context /**< */) 3375 { 3376 static const xcb_protocol_request_t xcb_req = { 3377 /* count */ 2, 3378 /* ext */ &xcb_x_print_id, 3379 /* opcode */ XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, 3380 /* isvoid */ 0 3381 }; 3382 3383 struct iovec xcb_parts[4]; 3384 xcb_x_print_print_get_image_resolution_cookie_t xcb_ret; 3385 xcb_x_print_print_get_image_resolution_request_t xcb_out; 3386 3387 xcb_out.context = context; 3388 3389 xcb_parts[2].iov_base = (char *) &xcb_out; 3390 xcb_parts[2].iov_len = sizeof(xcb_out); 3391 xcb_parts[3].iov_base = 0; 3392 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3393 3394 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 3395 return xcb_ret; 3396 } 3397 3398 3399 /***************************************************************************** 3400 ** 3401 ** xcb_x_print_print_get_image_resolution_cookie_t xcb_x_print_print_get_image_resolution_unchecked 3402 ** 3403 ** @param xcb_connection_t *c 3404 ** @param xcb_x_print_pcontext_t context 3405 ** @returns xcb_x_print_print_get_image_resolution_cookie_t 3406 ** 3407 *****************************************************************************/ 3408 3409 xcb_x_print_print_get_image_resolution_cookie_t 3410 xcb_x_print_print_get_image_resolution_unchecked (xcb_connection_t *c /**< */, 3411 xcb_x_print_pcontext_t context /**< */) 3412 { 3413 static const xcb_protocol_request_t xcb_req = { 3414 /* count */ 2, 3415 /* ext */ &xcb_x_print_id, 3416 /* opcode */ XCB_X_PRINT_PRINT_GET_IMAGE_RESOLUTION, 3417 /* isvoid */ 0 3418 }; 3419 3420 struct iovec xcb_parts[4]; 3421 xcb_x_print_print_get_image_resolution_cookie_t xcb_ret; 3422 xcb_x_print_print_get_image_resolution_request_t xcb_out; 3423 3424 xcb_out.context = context; 3425 3426 xcb_parts[2].iov_base = (char *) &xcb_out; 3427 xcb_parts[2].iov_len = sizeof(xcb_out); 3428 xcb_parts[3].iov_base = 0; 3429 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 3430 3431 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 3432 return xcb_ret; 3433 } 3434 3435 3436 /***************************************************************************** 3437 ** 3438 ** xcb_x_print_print_get_image_resolution_reply_t * xcb_x_print_print_get_image_resolution_reply 3439 ** 3440 ** @param xcb_connection_t *c 3441 ** @param xcb_x_print_print_get_image_resolution_cookie_t cookie 3442 ** @param xcb_generic_error_t **e 3443 ** @returns xcb_x_print_print_get_image_resolution_reply_t * 3444 ** 3445 *****************************************************************************/ 3446 3447 xcb_x_print_print_get_image_resolution_reply_t * 3448 xcb_x_print_print_get_image_resolution_reply (xcb_connection_t *c /**< */, 3449 xcb_x_print_print_get_image_resolution_cookie_t cookie /**< */, 3450 xcb_generic_error_t **e /**< */) 3451 { 3452 return (xcb_x_print_print_get_image_resolution_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 3453 } 3454 3455