1 /* 2 * This file generated automatically from screensaver.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 "screensaver.h" 15 16 #define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) 17 #include "xproto.h" 18 19 xcb_extension_t xcb_screensaver_id = { "MIT-SCREEN-SAVER", 0 }; 20 21 xcb_screensaver_query_version_cookie_t 22 xcb_screensaver_query_version (xcb_connection_t *c, 23 uint8_t client_major_version, 24 uint8_t client_minor_version) 25 { 26 static const xcb_protocol_request_t xcb_req = { 27 .count = 2, 28 .ext = &xcb_screensaver_id, 29 .opcode = XCB_SCREENSAVER_QUERY_VERSION, 30 .isvoid = 0 31 }; 32 33 struct iovec xcb_parts[4]; 34 xcb_screensaver_query_version_cookie_t xcb_ret; 35 xcb_screensaver_query_version_request_t xcb_out; 36 37 xcb_out.client_major_version = client_major_version; 38 xcb_out.client_minor_version = client_minor_version; 39 memset(xcb_out.pad0, 0, 2); 40 41 xcb_parts[2].iov_base = (char *) &xcb_out; 42 xcb_parts[2].iov_len = sizeof(xcb_out); 43 xcb_parts[3].iov_base = 0; 44 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 45 46 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 47 return xcb_ret; 48 } 49 50 xcb_screensaver_query_version_cookie_t 51 xcb_screensaver_query_version_unchecked (xcb_connection_t *c, 52 uint8_t client_major_version, 53 uint8_t client_minor_version) 54 { 55 static const xcb_protocol_request_t xcb_req = { 56 .count = 2, 57 .ext = &xcb_screensaver_id, 58 .opcode = XCB_SCREENSAVER_QUERY_VERSION, 59 .isvoid = 0 60 }; 61 62 struct iovec xcb_parts[4]; 63 xcb_screensaver_query_version_cookie_t xcb_ret; 64 xcb_screensaver_query_version_request_t xcb_out; 65 66 xcb_out.client_major_version = client_major_version; 67 xcb_out.client_minor_version = client_minor_version; 68 memset(xcb_out.pad0, 0, 2); 69 70 xcb_parts[2].iov_base = (char *) &xcb_out; 71 xcb_parts[2].iov_len = sizeof(xcb_out); 72 xcb_parts[3].iov_base = 0; 73 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 74 75 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 76 return xcb_ret; 77 } 78 79 xcb_screensaver_query_version_reply_t * 80 xcb_screensaver_query_version_reply (xcb_connection_t *c, 81 xcb_screensaver_query_version_cookie_t cookie /**< */, 82 xcb_generic_error_t **e) 83 { 84 return (xcb_screensaver_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 85 } 86 87 xcb_screensaver_query_info_cookie_t 88 xcb_screensaver_query_info (xcb_connection_t *c, 89 xcb_drawable_t drawable) 90 { 91 static const xcb_protocol_request_t xcb_req = { 92 .count = 2, 93 .ext = &xcb_screensaver_id, 94 .opcode = XCB_SCREENSAVER_QUERY_INFO, 95 .isvoid = 0 96 }; 97 98 struct iovec xcb_parts[4]; 99 xcb_screensaver_query_info_cookie_t xcb_ret; 100 xcb_screensaver_query_info_request_t xcb_out; 101 102 xcb_out.drawable = drawable; 103 104 xcb_parts[2].iov_base = (char *) &xcb_out; 105 xcb_parts[2].iov_len = sizeof(xcb_out); 106 xcb_parts[3].iov_base = 0; 107 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 108 109 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 110 return xcb_ret; 111 } 112 113 xcb_screensaver_query_info_cookie_t 114 xcb_screensaver_query_info_unchecked (xcb_connection_t *c, 115 xcb_drawable_t drawable) 116 { 117 static const xcb_protocol_request_t xcb_req = { 118 .count = 2, 119 .ext = &xcb_screensaver_id, 120 .opcode = XCB_SCREENSAVER_QUERY_INFO, 121 .isvoid = 0 122 }; 123 124 struct iovec xcb_parts[4]; 125 xcb_screensaver_query_info_cookie_t xcb_ret; 126 xcb_screensaver_query_info_request_t xcb_out; 127 128 xcb_out.drawable = drawable; 129 130 xcb_parts[2].iov_base = (char *) &xcb_out; 131 xcb_parts[2].iov_len = sizeof(xcb_out); 132 xcb_parts[3].iov_base = 0; 133 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 134 135 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 136 return xcb_ret; 137 } 138 139 xcb_screensaver_query_info_reply_t * 140 xcb_screensaver_query_info_reply (xcb_connection_t *c, 141 xcb_screensaver_query_info_cookie_t cookie /**< */, 142 xcb_generic_error_t **e) 143 { 144 return (xcb_screensaver_query_info_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); 145 } 146 147 xcb_void_cookie_t 148 xcb_screensaver_select_input_checked (xcb_connection_t *c, 149 xcb_drawable_t drawable, 150 uint32_t event_mask) 151 { 152 static const xcb_protocol_request_t xcb_req = { 153 .count = 2, 154 .ext = &xcb_screensaver_id, 155 .opcode = XCB_SCREENSAVER_SELECT_INPUT, 156 .isvoid = 1 157 }; 158 159 struct iovec xcb_parts[4]; 160 xcb_void_cookie_t xcb_ret; 161 xcb_screensaver_select_input_request_t xcb_out; 162 163 xcb_out.drawable = drawable; 164 xcb_out.event_mask = event_mask; 165 166 xcb_parts[2].iov_base = (char *) &xcb_out; 167 xcb_parts[2].iov_len = sizeof(xcb_out); 168 xcb_parts[3].iov_base = 0; 169 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 170 171 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 172 return xcb_ret; 173 } 174 175 xcb_void_cookie_t 176 xcb_screensaver_select_input (xcb_connection_t *c, 177 xcb_drawable_t drawable, 178 uint32_t event_mask) 179 { 180 static const xcb_protocol_request_t xcb_req = { 181 .count = 2, 182 .ext = &xcb_screensaver_id, 183 .opcode = XCB_SCREENSAVER_SELECT_INPUT, 184 .isvoid = 1 185 }; 186 187 struct iovec xcb_parts[4]; 188 xcb_void_cookie_t xcb_ret; 189 xcb_screensaver_select_input_request_t xcb_out; 190 191 xcb_out.drawable = drawable; 192 xcb_out.event_mask = event_mask; 193 194 xcb_parts[2].iov_base = (char *) &xcb_out; 195 xcb_parts[2].iov_len = sizeof(xcb_out); 196 xcb_parts[3].iov_base = 0; 197 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 198 199 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 200 return xcb_ret; 201 } 202 203 int 204 xcb_screensaver_set_attributes_value_list_serialize (void **_buffer, 205 uint32_t value_mask, 206 const xcb_screensaver_set_attributes_value_list_t *_aux) 207 { 208 char *xcb_out = *_buffer; 209 unsigned int xcb_buffer_len = 0; 210 unsigned int xcb_align_to = 0; 211 unsigned int xcb_padding_offset = 0; 212 213 unsigned int xcb_pad = 0; 214 char xcb_pad0[3] = {0, 0, 0}; 215 struct iovec xcb_parts[16]; 216 unsigned int xcb_parts_idx = 0; 217 unsigned int xcb_block_len = 0; 218 unsigned int i; 219 char *xcb_tmp; 220 221 if(value_mask & XCB_CW_BACK_PIXMAP) { 222 /* xcb_screensaver_set_attributes_value_list_t.background_pixmap */ 223 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixmap; 224 xcb_block_len += sizeof(xcb_pixmap_t); 225 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); 226 xcb_parts_idx++; 227 xcb_align_to = ALIGNOF(xcb_pixmap_t); 228 } 229 if(value_mask & XCB_CW_BACK_PIXEL) { 230 /* xcb_screensaver_set_attributes_value_list_t.background_pixel */ 231 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->background_pixel; 232 xcb_block_len += sizeof(uint32_t); 233 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 234 xcb_parts_idx++; 235 xcb_align_to = ALIGNOF(uint32_t); 236 } 237 if(value_mask & XCB_CW_BORDER_PIXMAP) { 238 /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */ 239 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixmap; 240 xcb_block_len += sizeof(xcb_pixmap_t); 241 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_pixmap_t); 242 xcb_parts_idx++; 243 xcb_align_to = ALIGNOF(xcb_pixmap_t); 244 } 245 if(value_mask & XCB_CW_BORDER_PIXEL) { 246 /* xcb_screensaver_set_attributes_value_list_t.border_pixel */ 247 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->border_pixel; 248 xcb_block_len += sizeof(uint32_t); 249 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 250 xcb_parts_idx++; 251 xcb_align_to = ALIGNOF(uint32_t); 252 } 253 if(value_mask & XCB_CW_BIT_GRAVITY) { 254 /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */ 255 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->bit_gravity; 256 xcb_block_len += sizeof(uint32_t); 257 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 258 xcb_parts_idx++; 259 xcb_align_to = ALIGNOF(uint32_t); 260 } 261 if(value_mask & XCB_CW_WIN_GRAVITY) { 262 /* xcb_screensaver_set_attributes_value_list_t.win_gravity */ 263 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->win_gravity; 264 xcb_block_len += sizeof(uint32_t); 265 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 266 xcb_parts_idx++; 267 xcb_align_to = ALIGNOF(uint32_t); 268 } 269 if(value_mask & XCB_CW_BACKING_STORE) { 270 /* xcb_screensaver_set_attributes_value_list_t.backing_store */ 271 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_store; 272 xcb_block_len += sizeof(uint32_t); 273 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 274 xcb_parts_idx++; 275 xcb_align_to = ALIGNOF(uint32_t); 276 } 277 if(value_mask & XCB_CW_BACKING_PLANES) { 278 /* xcb_screensaver_set_attributes_value_list_t.backing_planes */ 279 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_planes; 280 xcb_block_len += sizeof(uint32_t); 281 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 282 xcb_parts_idx++; 283 xcb_align_to = ALIGNOF(uint32_t); 284 } 285 if(value_mask & XCB_CW_BACKING_PIXEL) { 286 /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */ 287 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->backing_pixel; 288 xcb_block_len += sizeof(uint32_t); 289 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 290 xcb_parts_idx++; 291 xcb_align_to = ALIGNOF(uint32_t); 292 } 293 if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { 294 /* xcb_screensaver_set_attributes_value_list_t.override_redirect */ 295 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->override_redirect; 296 xcb_block_len += sizeof(xcb_bool32_t); 297 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); 298 xcb_parts_idx++; 299 xcb_align_to = ALIGNOF(xcb_bool32_t); 300 } 301 if(value_mask & XCB_CW_SAVE_UNDER) { 302 /* xcb_screensaver_set_attributes_value_list_t.save_under */ 303 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->save_under; 304 xcb_block_len += sizeof(xcb_bool32_t); 305 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_bool32_t); 306 xcb_parts_idx++; 307 xcb_align_to = ALIGNOF(xcb_bool32_t); 308 } 309 if(value_mask & XCB_CW_EVENT_MASK) { 310 /* xcb_screensaver_set_attributes_value_list_t.event_mask */ 311 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->event_mask; 312 xcb_block_len += sizeof(uint32_t); 313 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 314 xcb_parts_idx++; 315 xcb_align_to = ALIGNOF(uint32_t); 316 } 317 if(value_mask & XCB_CW_DONT_PROPAGATE) { 318 /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */ 319 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->do_not_propogate_mask; 320 xcb_block_len += sizeof(uint32_t); 321 xcb_parts[xcb_parts_idx].iov_len = sizeof(uint32_t); 322 xcb_parts_idx++; 323 xcb_align_to = ALIGNOF(uint32_t); 324 } 325 if(value_mask & XCB_CW_COLORMAP) { 326 /* xcb_screensaver_set_attributes_value_list_t.colormap */ 327 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->colormap; 328 xcb_block_len += sizeof(xcb_colormap_t); 329 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_colormap_t); 330 xcb_parts_idx++; 331 xcb_align_to = ALIGNOF(xcb_colormap_t); 332 } 333 if(value_mask & XCB_CW_CURSOR) { 334 /* xcb_screensaver_set_attributes_value_list_t.cursor */ 335 xcb_parts[xcb_parts_idx].iov_base = (char *) &_aux->cursor; 336 xcb_block_len += sizeof(xcb_cursor_t); 337 xcb_parts[xcb_parts_idx].iov_len = sizeof(xcb_cursor_t); 338 xcb_parts_idx++; 339 xcb_align_to = ALIGNOF(xcb_cursor_t); 340 } 341 /* insert padding */ 342 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 343 xcb_buffer_len += xcb_block_len + xcb_pad; 344 if (0 != xcb_pad) { 345 xcb_parts[xcb_parts_idx].iov_base = xcb_pad0; 346 xcb_parts[xcb_parts_idx].iov_len = xcb_pad; 347 xcb_parts_idx++; 348 xcb_pad = 0; 349 } 350 xcb_block_len = 0; 351 xcb_padding_offset = 0; 352 353 if (NULL == xcb_out) { 354 /* allocate memory */ 355 xcb_out = malloc(xcb_buffer_len); 356 *_buffer = xcb_out; 357 } 358 359 xcb_tmp = xcb_out; 360 for(i=0; i<xcb_parts_idx; i++) { 361 if (0 != xcb_parts[i].iov_base && 0 != xcb_parts[i].iov_len) 362 memcpy(xcb_tmp, xcb_parts[i].iov_base, xcb_parts[i].iov_len); 363 if (0 != xcb_parts[i].iov_len) 364 xcb_tmp += xcb_parts[i].iov_len; 365 } 366 367 return xcb_buffer_len; 368 } 369 370 int 371 xcb_screensaver_set_attributes_value_list_unpack (const void *_buffer, 372 uint32_t value_mask, 373 xcb_screensaver_set_attributes_value_list_t *_aux) 374 { 375 char *xcb_tmp = (char *)_buffer; 376 unsigned int xcb_buffer_len = 0; 377 unsigned int xcb_block_len = 0; 378 unsigned int xcb_pad = 0; 379 unsigned int xcb_align_to = 0; 380 unsigned int xcb_padding_offset = 0; 381 382 383 if(value_mask & XCB_CW_BACK_PIXMAP) { 384 /* xcb_screensaver_set_attributes_value_list_t.background_pixmap */ 385 _aux->background_pixmap = *(xcb_pixmap_t *)xcb_tmp; 386 xcb_block_len += sizeof(xcb_pixmap_t); 387 xcb_tmp += sizeof(xcb_pixmap_t); 388 xcb_align_to = ALIGNOF(xcb_pixmap_t); 389 } 390 if(value_mask & XCB_CW_BACK_PIXEL) { 391 /* xcb_screensaver_set_attributes_value_list_t.background_pixel */ 392 _aux->background_pixel = *(uint32_t *)xcb_tmp; 393 xcb_block_len += sizeof(uint32_t); 394 xcb_tmp += sizeof(uint32_t); 395 xcb_align_to = ALIGNOF(uint32_t); 396 } 397 if(value_mask & XCB_CW_BORDER_PIXMAP) { 398 /* xcb_screensaver_set_attributes_value_list_t.border_pixmap */ 399 _aux->border_pixmap = *(xcb_pixmap_t *)xcb_tmp; 400 xcb_block_len += sizeof(xcb_pixmap_t); 401 xcb_tmp += sizeof(xcb_pixmap_t); 402 xcb_align_to = ALIGNOF(xcb_pixmap_t); 403 } 404 if(value_mask & XCB_CW_BORDER_PIXEL) { 405 /* xcb_screensaver_set_attributes_value_list_t.border_pixel */ 406 _aux->border_pixel = *(uint32_t *)xcb_tmp; 407 xcb_block_len += sizeof(uint32_t); 408 xcb_tmp += sizeof(uint32_t); 409 xcb_align_to = ALIGNOF(uint32_t); 410 } 411 if(value_mask & XCB_CW_BIT_GRAVITY) { 412 /* xcb_screensaver_set_attributes_value_list_t.bit_gravity */ 413 _aux->bit_gravity = *(uint32_t *)xcb_tmp; 414 xcb_block_len += sizeof(uint32_t); 415 xcb_tmp += sizeof(uint32_t); 416 xcb_align_to = ALIGNOF(uint32_t); 417 } 418 if(value_mask & XCB_CW_WIN_GRAVITY) { 419 /* xcb_screensaver_set_attributes_value_list_t.win_gravity */ 420 _aux->win_gravity = *(uint32_t *)xcb_tmp; 421 xcb_block_len += sizeof(uint32_t); 422 xcb_tmp += sizeof(uint32_t); 423 xcb_align_to = ALIGNOF(uint32_t); 424 } 425 if(value_mask & XCB_CW_BACKING_STORE) { 426 /* xcb_screensaver_set_attributes_value_list_t.backing_store */ 427 _aux->backing_store = *(uint32_t *)xcb_tmp; 428 xcb_block_len += sizeof(uint32_t); 429 xcb_tmp += sizeof(uint32_t); 430 xcb_align_to = ALIGNOF(uint32_t); 431 } 432 if(value_mask & XCB_CW_BACKING_PLANES) { 433 /* xcb_screensaver_set_attributes_value_list_t.backing_planes */ 434 _aux->backing_planes = *(uint32_t *)xcb_tmp; 435 xcb_block_len += sizeof(uint32_t); 436 xcb_tmp += sizeof(uint32_t); 437 xcb_align_to = ALIGNOF(uint32_t); 438 } 439 if(value_mask & XCB_CW_BACKING_PIXEL) { 440 /* xcb_screensaver_set_attributes_value_list_t.backing_pixel */ 441 _aux->backing_pixel = *(uint32_t *)xcb_tmp; 442 xcb_block_len += sizeof(uint32_t); 443 xcb_tmp += sizeof(uint32_t); 444 xcb_align_to = ALIGNOF(uint32_t); 445 } 446 if(value_mask & XCB_CW_OVERRIDE_REDIRECT) { 447 /* xcb_screensaver_set_attributes_value_list_t.override_redirect */ 448 _aux->override_redirect = *(xcb_bool32_t *)xcb_tmp; 449 xcb_block_len += sizeof(xcb_bool32_t); 450 xcb_tmp += sizeof(xcb_bool32_t); 451 xcb_align_to = ALIGNOF(xcb_bool32_t); 452 } 453 if(value_mask & XCB_CW_SAVE_UNDER) { 454 /* xcb_screensaver_set_attributes_value_list_t.save_under */ 455 _aux->save_under = *(xcb_bool32_t *)xcb_tmp; 456 xcb_block_len += sizeof(xcb_bool32_t); 457 xcb_tmp += sizeof(xcb_bool32_t); 458 xcb_align_to = ALIGNOF(xcb_bool32_t); 459 } 460 if(value_mask & XCB_CW_EVENT_MASK) { 461 /* xcb_screensaver_set_attributes_value_list_t.event_mask */ 462 _aux->event_mask = *(uint32_t *)xcb_tmp; 463 xcb_block_len += sizeof(uint32_t); 464 xcb_tmp += sizeof(uint32_t); 465 xcb_align_to = ALIGNOF(uint32_t); 466 } 467 if(value_mask & XCB_CW_DONT_PROPAGATE) { 468 /* xcb_screensaver_set_attributes_value_list_t.do_not_propogate_mask */ 469 _aux->do_not_propogate_mask = *(uint32_t *)xcb_tmp; 470 xcb_block_len += sizeof(uint32_t); 471 xcb_tmp += sizeof(uint32_t); 472 xcb_align_to = ALIGNOF(uint32_t); 473 } 474 if(value_mask & XCB_CW_COLORMAP) { 475 /* xcb_screensaver_set_attributes_value_list_t.colormap */ 476 _aux->colormap = *(xcb_colormap_t *)xcb_tmp; 477 xcb_block_len += sizeof(xcb_colormap_t); 478 xcb_tmp += sizeof(xcb_colormap_t); 479 xcb_align_to = ALIGNOF(xcb_colormap_t); 480 } 481 if(value_mask & XCB_CW_CURSOR) { 482 /* xcb_screensaver_set_attributes_value_list_t.cursor */ 483 _aux->cursor = *(xcb_cursor_t *)xcb_tmp; 484 xcb_block_len += sizeof(xcb_cursor_t); 485 xcb_tmp += sizeof(xcb_cursor_t); 486 xcb_align_to = ALIGNOF(xcb_cursor_t); 487 } 488 /* insert padding */ 489 xcb_pad = -(xcb_block_len + xcb_padding_offset) & (xcb_align_to - 1); 490 xcb_buffer_len += xcb_block_len + xcb_pad; 491 if (0 != xcb_pad) { 492 xcb_tmp += xcb_pad; 493 xcb_pad = 0; 494 } 495 xcb_block_len = 0; 496 xcb_padding_offset = 0; 497 498 return xcb_buffer_len; 499 } 500 501 int 502 xcb_screensaver_set_attributes_value_list_sizeof (const void *_buffer, 503 uint32_t value_mask) 504 { 505 xcb_screensaver_set_attributes_value_list_t _aux; 506 return xcb_screensaver_set_attributes_value_list_unpack(_buffer, value_mask, &_aux); 507 } 508 509 int 510 xcb_screensaver_set_attributes_sizeof (const void *_buffer) 511 { 512 char *xcb_tmp = (char *)_buffer; 513 const xcb_screensaver_set_attributes_request_t *_aux = (xcb_screensaver_set_attributes_request_t *)_buffer; 514 unsigned int xcb_buffer_len = 0; 515 unsigned int xcb_block_len = 0; 516 unsigned int xcb_pad = 0; 517 unsigned int xcb_align_to = 0; 518 519 520 xcb_block_len += sizeof(xcb_screensaver_set_attributes_request_t); 521 xcb_tmp += xcb_block_len; 522 xcb_buffer_len += xcb_block_len; 523 xcb_block_len = 0; 524 /* value_list */ 525 xcb_block_len += xcb_screensaver_set_attributes_value_list_sizeof(xcb_tmp, _aux->value_mask); 526 xcb_tmp += xcb_block_len; 527 xcb_align_to = ALIGNOF(char); 528 /* insert padding */ 529 xcb_pad = -xcb_block_len & (xcb_align_to - 1); 530 xcb_buffer_len += xcb_block_len + xcb_pad; 531 if (0 != xcb_pad) { 532 xcb_tmp += xcb_pad; 533 xcb_pad = 0; 534 } 535 xcb_block_len = 0; 536 537 return xcb_buffer_len; 538 } 539 540 xcb_void_cookie_t 541 xcb_screensaver_set_attributes_checked (xcb_connection_t *c, 542 xcb_drawable_t drawable, 543 int16_t x, 544 int16_t y, 545 uint16_t width, 546 uint16_t height, 547 uint16_t border_width, 548 uint8_t _class, 549 uint8_t depth, 550 xcb_visualid_t visual, 551 uint32_t value_mask, 552 const void *value_list) 553 { 554 static const xcb_protocol_request_t xcb_req = { 555 .count = 3, 556 .ext = &xcb_screensaver_id, 557 .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, 558 .isvoid = 1 559 }; 560 561 struct iovec xcb_parts[5]; 562 xcb_void_cookie_t xcb_ret; 563 xcb_screensaver_set_attributes_request_t xcb_out; 564 565 xcb_out.drawable = drawable; 566 xcb_out.x = x; 567 xcb_out.y = y; 568 xcb_out.width = width; 569 xcb_out.height = height; 570 xcb_out.border_width = border_width; 571 xcb_out._class = _class; 572 xcb_out.depth = depth; 573 xcb_out.visual = visual; 574 xcb_out.value_mask = value_mask; 575 576 xcb_parts[2].iov_base = (char *) &xcb_out; 577 xcb_parts[2].iov_len = sizeof(xcb_out); 578 xcb_parts[3].iov_base = 0; 579 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 580 /* xcb_screensaver_set_attributes_value_list_t value_list */ 581 xcb_parts[4].iov_base = (char *) value_list; 582 xcb_parts[4].iov_len = 583 xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask); 584 585 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 586 return xcb_ret; 587 } 588 589 xcb_void_cookie_t 590 xcb_screensaver_set_attributes (xcb_connection_t *c, 591 xcb_drawable_t drawable, 592 int16_t x, 593 int16_t y, 594 uint16_t width, 595 uint16_t height, 596 uint16_t border_width, 597 uint8_t _class, 598 uint8_t depth, 599 xcb_visualid_t visual, 600 uint32_t value_mask, 601 const void *value_list) 602 { 603 static const xcb_protocol_request_t xcb_req = { 604 .count = 3, 605 .ext = &xcb_screensaver_id, 606 .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, 607 .isvoid = 1 608 }; 609 610 struct iovec xcb_parts[5]; 611 xcb_void_cookie_t xcb_ret; 612 xcb_screensaver_set_attributes_request_t xcb_out; 613 614 xcb_out.drawable = drawable; 615 xcb_out.x = x; 616 xcb_out.y = y; 617 xcb_out.width = width; 618 xcb_out.height = height; 619 xcb_out.border_width = border_width; 620 xcb_out._class = _class; 621 xcb_out.depth = depth; 622 xcb_out.visual = visual; 623 xcb_out.value_mask = value_mask; 624 625 xcb_parts[2].iov_base = (char *) &xcb_out; 626 xcb_parts[2].iov_len = sizeof(xcb_out); 627 xcb_parts[3].iov_base = 0; 628 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 629 /* xcb_screensaver_set_attributes_value_list_t value_list */ 630 xcb_parts[4].iov_base = (char *) value_list; 631 xcb_parts[4].iov_len = 632 xcb_screensaver_set_attributes_value_list_sizeof (value_list, value_mask); 633 634 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 635 return xcb_ret; 636 } 637 638 xcb_void_cookie_t 639 xcb_screensaver_set_attributes_aux_checked (xcb_connection_t *c, 640 xcb_drawable_t drawable, 641 int16_t x, 642 int16_t y, 643 uint16_t width, 644 uint16_t height, 645 uint16_t border_width, 646 uint8_t _class, 647 uint8_t depth, 648 xcb_visualid_t visual, 649 uint32_t value_mask, 650 const xcb_screensaver_set_attributes_value_list_t *value_list) 651 { 652 static const xcb_protocol_request_t xcb_req = { 653 .count = 3, 654 .ext = &xcb_screensaver_id, 655 .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, 656 .isvoid = 1 657 }; 658 659 struct iovec xcb_parts[5]; 660 xcb_void_cookie_t xcb_ret; 661 xcb_screensaver_set_attributes_request_t xcb_out; 662 void *xcb_aux0 = 0; 663 664 xcb_out.drawable = drawable; 665 xcb_out.x = x; 666 xcb_out.y = y; 667 xcb_out.width = width; 668 xcb_out.height = height; 669 xcb_out.border_width = border_width; 670 xcb_out._class = _class; 671 xcb_out.depth = depth; 672 xcb_out.visual = visual; 673 xcb_out.value_mask = value_mask; 674 675 xcb_parts[2].iov_base = (char *) &xcb_out; 676 xcb_parts[2].iov_len = sizeof(xcb_out); 677 xcb_parts[3].iov_base = 0; 678 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 679 /* xcb_screensaver_set_attributes_value_list_t value_list */ 680 xcb_parts[4].iov_len = 681 xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); 682 xcb_parts[4].iov_base = xcb_aux0; 683 684 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 685 free(xcb_aux0); 686 return xcb_ret; 687 } 688 689 xcb_void_cookie_t 690 xcb_screensaver_set_attributes_aux (xcb_connection_t *c, 691 xcb_drawable_t drawable, 692 int16_t x, 693 int16_t y, 694 uint16_t width, 695 uint16_t height, 696 uint16_t border_width, 697 uint8_t _class, 698 uint8_t depth, 699 xcb_visualid_t visual, 700 uint32_t value_mask, 701 const xcb_screensaver_set_attributes_value_list_t *value_list) 702 { 703 static const xcb_protocol_request_t xcb_req = { 704 .count = 3, 705 .ext = &xcb_screensaver_id, 706 .opcode = XCB_SCREENSAVER_SET_ATTRIBUTES, 707 .isvoid = 1 708 }; 709 710 struct iovec xcb_parts[5]; 711 xcb_void_cookie_t xcb_ret; 712 xcb_screensaver_set_attributes_request_t xcb_out; 713 void *xcb_aux0 = 0; 714 715 xcb_out.drawable = drawable; 716 xcb_out.x = x; 717 xcb_out.y = y; 718 xcb_out.width = width; 719 xcb_out.height = height; 720 xcb_out.border_width = border_width; 721 xcb_out._class = _class; 722 xcb_out.depth = depth; 723 xcb_out.visual = visual; 724 xcb_out.value_mask = value_mask; 725 726 xcb_parts[2].iov_base = (char *) &xcb_out; 727 xcb_parts[2].iov_len = sizeof(xcb_out); 728 xcb_parts[3].iov_base = 0; 729 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 730 /* xcb_screensaver_set_attributes_value_list_t value_list */ 731 xcb_parts[4].iov_len = 732 xcb_screensaver_set_attributes_value_list_serialize (&xcb_aux0, value_mask, value_list); 733 xcb_parts[4].iov_base = xcb_aux0; 734 735 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 736 free(xcb_aux0); 737 return xcb_ret; 738 } 739 740 void * 741 xcb_screensaver_set_attributes_value_list (const xcb_screensaver_set_attributes_request_t *R) 742 { 743 return (void *) (R + 1); 744 } 745 746 xcb_void_cookie_t 747 xcb_screensaver_unset_attributes_checked (xcb_connection_t *c, 748 xcb_drawable_t drawable) 749 { 750 static const xcb_protocol_request_t xcb_req = { 751 .count = 2, 752 .ext = &xcb_screensaver_id, 753 .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES, 754 .isvoid = 1 755 }; 756 757 struct iovec xcb_parts[4]; 758 xcb_void_cookie_t xcb_ret; 759 xcb_screensaver_unset_attributes_request_t xcb_out; 760 761 xcb_out.drawable = drawable; 762 763 xcb_parts[2].iov_base = (char *) &xcb_out; 764 xcb_parts[2].iov_len = sizeof(xcb_out); 765 xcb_parts[3].iov_base = 0; 766 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 767 768 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 769 return xcb_ret; 770 } 771 772 xcb_void_cookie_t 773 xcb_screensaver_unset_attributes (xcb_connection_t *c, 774 xcb_drawable_t drawable) 775 { 776 static const xcb_protocol_request_t xcb_req = { 777 .count = 2, 778 .ext = &xcb_screensaver_id, 779 .opcode = XCB_SCREENSAVER_UNSET_ATTRIBUTES, 780 .isvoid = 1 781 }; 782 783 struct iovec xcb_parts[4]; 784 xcb_void_cookie_t xcb_ret; 785 xcb_screensaver_unset_attributes_request_t xcb_out; 786 787 xcb_out.drawable = drawable; 788 789 xcb_parts[2].iov_base = (char *) &xcb_out; 790 xcb_parts[2].iov_len = sizeof(xcb_out); 791 xcb_parts[3].iov_base = 0; 792 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 793 794 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 795 return xcb_ret; 796 } 797 798 xcb_void_cookie_t 799 xcb_screensaver_suspend_checked (xcb_connection_t *c, 800 uint32_t suspend) 801 { 802 static const xcb_protocol_request_t xcb_req = { 803 .count = 2, 804 .ext = &xcb_screensaver_id, 805 .opcode = XCB_SCREENSAVER_SUSPEND, 806 .isvoid = 1 807 }; 808 809 struct iovec xcb_parts[4]; 810 xcb_void_cookie_t xcb_ret; 811 xcb_screensaver_suspend_request_t xcb_out; 812 813 xcb_out.suspend = suspend; 814 815 xcb_parts[2].iov_base = (char *) &xcb_out; 816 xcb_parts[2].iov_len = sizeof(xcb_out); 817 xcb_parts[3].iov_base = 0; 818 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 819 820 xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); 821 return xcb_ret; 822 } 823 824 xcb_void_cookie_t 825 xcb_screensaver_suspend (xcb_connection_t *c, 826 uint32_t suspend) 827 { 828 static const xcb_protocol_request_t xcb_req = { 829 .count = 2, 830 .ext = &xcb_screensaver_id, 831 .opcode = XCB_SCREENSAVER_SUSPEND, 832 .isvoid = 1 833 }; 834 835 struct iovec xcb_parts[4]; 836 xcb_void_cookie_t xcb_ret; 837 xcb_screensaver_suspend_request_t xcb_out; 838 839 xcb_out.suspend = suspend; 840 841 xcb_parts[2].iov_base = (char *) &xcb_out; 842 xcb_parts[2].iov_len = sizeof(xcb_out); 843 xcb_parts[3].iov_base = 0; 844 xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; 845 846 xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); 847 return xcb_ret; 848 } 849 850
Indexes created Sat Feb 28 05:31:39 UTC 2026