From 80ab0233688c9df9fd48265b6f9e7ab7cd589dbc Mon Sep 17 00:00:00 2001 From: dec05eba Date: Sat, 19 Aug 2023 23:50:04 +0200 Subject: Initial commit --- depends/libxcb/src/xfixes.c | 2699 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 2699 insertions(+) create mode 100644 depends/libxcb/src/xfixes.c (limited to 'depends/libxcb/src/xfixes.c') diff --git a/depends/libxcb/src/xfixes.c b/depends/libxcb/src/xfixes.c new file mode 100644 index 0000000..87b198d --- /dev/null +++ b/depends/libxcb/src/xfixes.c @@ -0,0 +1,2699 @@ +/* + * This file generated automatically from xfixes.xml by c_client.py. + * Edit at your peril. + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#include +#include +#include +#include /* for offsetof() */ +#include "xcbext.h" +#include "xfixes.h" + +#define ALIGNOF(type) offsetof(struct { char dummy; type member; }, member) +#include "xproto.h" +#include "render.h" +#include "shape.h" + +xcb_extension_t xcb_xfixes_id = { "XFIXES", 0 }; + +xcb_xfixes_query_version_cookie_t +xcb_xfixes_query_version (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_QUERY_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_query_version_cookie_t xcb_ret; + xcb_xfixes_query_version_request_t xcb_out; + + xcb_out.client_major_version = client_major_version; + xcb_out.client_minor_version = client_minor_version; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_query_version_cookie_t +xcb_xfixes_query_version_unchecked (xcb_connection_t *c, + uint32_t client_major_version, + uint32_t client_minor_version) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_QUERY_VERSION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_query_version_cookie_t xcb_ret; + xcb_xfixes_query_version_request_t xcb_out; + + xcb_out.client_major_version = client_major_version; + xcb_out.client_minor_version = client_minor_version; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_query_version_reply_t * +xcb_xfixes_query_version_reply (xcb_connection_t *c, + xcb_xfixes_query_version_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_query_version_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_xfixes_change_save_set_checked (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_SAVE_SET, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_save_set_request_t xcb_out; + + xcb_out.mode = mode; + xcb_out.target = target; + xcb_out.map = map; + xcb_out.pad0 = 0; + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_change_save_set (xcb_connection_t *c, + uint8_t mode, + uint8_t target, + uint8_t map, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_SAVE_SET, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_save_set_request_t xcb_out; + + xcb_out.mode = mode; + xcb_out.target = target; + xcb_out.map = map; + xcb_out.pad0 = 0; + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_select_selection_input_checked (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_select_selection_input_request_t xcb_out; + + xcb_out.window = window; + xcb_out.selection = selection; + xcb_out.event_mask = event_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_select_selection_input (xcb_connection_t *c, + xcb_window_t window, + xcb_atom_t selection, + uint32_t event_mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_SELECTION_INPUT, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_select_selection_input_request_t xcb_out; + + xcb_out.window = window; + xcb_out.selection = selection; + xcb_out.event_mask = event_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_select_cursor_input_checked (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_select_cursor_input_request_t xcb_out; + + xcb_out.window = window; + xcb_out.event_mask = event_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_select_cursor_input (xcb_connection_t *c, + xcb_window_t window, + uint32_t event_mask) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SELECT_CURSOR_INPUT, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_select_cursor_input_request_t xcb_out; + + xcb_out.window = window; + xcb_out.event_mask = event_mask; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_xfixes_get_cursor_image_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_image_reply_t *_aux = (xcb_xfixes_get_cursor_image_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* cursor_image */ + xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_xfixes_get_cursor_image_cookie_t +xcb_xfixes_get_cursor_image (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_image_cookie_t xcb_ret; + xcb_xfixes_get_cursor_image_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_cursor_image_cookie_t +xcb_xfixes_get_cursor_image_unchecked (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_image_cookie_t xcb_ret; + xcb_xfixes_get_cursor_image_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint32_t * +xcb_xfixes_get_cursor_image_cursor_image (const xcb_xfixes_get_cursor_image_reply_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_xfixes_get_cursor_image_cursor_image_length (const xcb_xfixes_get_cursor_image_reply_t *R) +{ + return (R->width * R->height); +} + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_image_cursor_image_end (const xcb_xfixes_get_cursor_image_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_xfixes_get_cursor_image_reply_t * +xcb_xfixes_get_cursor_image_reply (xcb_connection_t *c, + xcb_xfixes_get_cursor_image_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_get_cursor_image_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +void +xcb_xfixes_region_next (xcb_xfixes_region_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_xfixes_region_t); +} + +xcb_generic_iterator_t +xcb_xfixes_region_end (xcb_xfixes_region_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_xfixes_create_region_sizeof (const void *_buffer, + uint32_t rectangles_len) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_create_region_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ + xcb_parts[4].iov_base = (char *) rectangles; + xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ + xcb_parts[4].iov_base = (char *) rectangles; + xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_rectangle_t * +xcb_xfixes_create_region_rectangles (const xcb_xfixes_create_region_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_xfixes_create_region_rectangles_length (const xcb_xfixes_create_region_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_xfixes_create_region_rectangles_iterator (const xcb_xfixes_create_region_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_xfixes_create_region_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_bitmap_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_bitmap_request_t xcb_out; + + xcb_out.region = region; + xcb_out.bitmap = bitmap; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_bitmap (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_pixmap_t bitmap) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_BITMAP, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_bitmap_request_t xcb_out; + + xcb_out.region = region; + xcb_out.bitmap = bitmap; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_window_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_window_request_t xcb_out; + + xcb_out.region = region; + xcb_out.window = window; + xcb_out.kind = kind; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_window (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_window_t window, + xcb_shape_kind_t kind) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_WINDOW, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_window_request_t xcb_out; + + xcb_out.region = region; + xcb_out.window = window; + xcb_out.kind = kind; + memset(xcb_out.pad0, 0, 3); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_gc_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_gc_request_t xcb_out; + + xcb_out.region = region; + xcb_out.gc = gc; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_gc (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_gcontext_t gc) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_GC, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_gc_request_t xcb_out; + + xcb_out.region = region; + xcb_out.gc = gc; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_picture_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_picture_request_t xcb_out; + + xcb_out.region = region; + xcb_out.picture = picture; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_region_from_picture (xcb_connection_t *c, + xcb_xfixes_region_t region, + xcb_render_picture_t picture) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_REGION_FROM_PICTURE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_region_from_picture_request_t xcb_out; + + xcb_out.region = region; + xcb_out.picture = picture; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_destroy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DESTROY_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_destroy_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_destroy_region (xcb_connection_t *c, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DESTROY_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_destroy_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_xfixes_set_region_sizeof (const void *_buffer, + uint32_t rectangles_len) +{ + char *xcb_tmp = (char *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_set_region_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* rectangles */ + xcb_block_len += rectangles_len * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_xfixes_set_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ + xcb_parts[4].iov_base = (char *) rectangles; + xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + uint32_t rectangles_len, + const xcb_rectangle_t *rectangles) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* xcb_rectangle_t rectangles */ + xcb_parts[4].iov_base = (char *) rectangles; + xcb_parts[4].iov_len = rectangles_len * sizeof(xcb_rectangle_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_rectangle_t * +xcb_xfixes_set_region_rectangles (const xcb_xfixes_set_region_request_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_xfixes_set_region_rectangles_length (const xcb_xfixes_set_region_request_t *R) +{ + return (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t)); +} + +xcb_rectangle_iterator_t +xcb_xfixes_set_region_rectangles_iterator (const xcb_xfixes_set_region_request_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (((R->length * 4) - sizeof(xcb_xfixes_set_region_request_t))/sizeof(xcb_rectangle_t)); + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_xfixes_copy_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_COPY_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_copy_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_copy_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_COPY_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_copy_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_union_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_UNION_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_union_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_union_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_UNION_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_union_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_intersect_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INTERSECT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_intersect_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_intersect_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INTERSECT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_intersect_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_subtract_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SUBTRACT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_subtract_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_subtract_region (xcb_connection_t *c, + xcb_xfixes_region_t source1, + xcb_xfixes_region_t source2, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SUBTRACT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_subtract_region_request_t xcb_out; + + xcb_out.source1 = source1; + xcb_out.source2 = source2; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_invert_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INVERT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_invert_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.bounds = bounds; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_invert_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_rectangle_t bounds, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_INVERT_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_invert_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.bounds = bounds; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_translate_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_TRANSLATE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_translate_region_request_t xcb_out; + + xcb_out.region = region; + xcb_out.dx = dx; + xcb_out.dy = dy; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_translate_region (xcb_connection_t *c, + xcb_xfixes_region_t region, + int16_t dx, + int16_t dy) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_TRANSLATE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_translate_region_request_t xcb_out; + + xcb_out.region = region; + xcb_out.dx = dx; + xcb_out.dy = dy; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_region_extents_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_REGION_EXTENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_region_extents_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_region_extents (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_REGION_EXTENTS, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_region_extents_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_xfixes_fetch_region_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_fetch_region_reply_t *_aux = (xcb_xfixes_fetch_region_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_fetch_region_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* rectangles */ + xcb_block_len += (_aux->length / 2) * sizeof(xcb_rectangle_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(xcb_rectangle_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_xfixes_fetch_region_cookie_t +xcb_xfixes_fetch_region (xcb_connection_t *c, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_FETCH_REGION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_fetch_region_cookie_t xcb_ret; + xcb_xfixes_fetch_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_fetch_region_cookie_t +xcb_xfixes_fetch_region_unchecked (xcb_connection_t *c, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_FETCH_REGION, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_fetch_region_cookie_t xcb_ret; + xcb_xfixes_fetch_region_request_t xcb_out; + + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_rectangle_t * +xcb_xfixes_fetch_region_rectangles (const xcb_xfixes_fetch_region_reply_t *R) +{ + return (xcb_rectangle_t *) (R + 1); +} + +int +xcb_xfixes_fetch_region_rectangles_length (const xcb_xfixes_fetch_region_reply_t *R) +{ + return (R->length / 2); +} + +xcb_rectangle_iterator_t +xcb_xfixes_fetch_region_rectangles_iterator (const xcb_xfixes_fetch_region_reply_t *R) +{ + xcb_rectangle_iterator_t i; + i.data = (xcb_rectangle_t *) (R + 1); + i.rem = (R->length / 2); + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_xfixes_fetch_region_reply_t * +xcb_xfixes_fetch_region_reply (xcb_connection_t *c, + xcb_xfixes_fetch_region_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_fetch_region_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_xfixes_set_gc_clip_region_checked (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_GC_CLIP_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_gc_clip_region_request_t xcb_out; + + xcb_out.gc = gc; + xcb_out.region = region; + xcb_out.x_origin = x_origin; + xcb_out.y_origin = y_origin; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_gc_clip_region (xcb_connection_t *c, + xcb_gcontext_t gc, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_GC_CLIP_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_gc_clip_region_request_t xcb_out; + + xcb_out.gc = gc; + xcb_out.region = region; + xcb_out.x_origin = x_origin; + xcb_out.y_origin = y_origin; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_window_shape_region_checked (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_window_shape_region_request_t xcb_out; + + xcb_out.dest = dest; + xcb_out.dest_kind = dest_kind; + memset(xcb_out.pad0, 0, 3); + xcb_out.x_offset = x_offset; + xcb_out.y_offset = y_offset; + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_window_shape_region (xcb_connection_t *c, + xcb_window_t dest, + xcb_shape_kind_t dest_kind, + int16_t x_offset, + int16_t y_offset, + xcb_xfixes_region_t region) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_WINDOW_SHAPE_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_window_shape_region_request_t xcb_out; + + xcb_out.dest = dest; + xcb_out.dest_kind = dest_kind; + memset(xcb_out.pad0, 0, 3); + xcb_out.x_offset = x_offset; + xcb_out.y_offset = y_offset; + xcb_out.region = region; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_picture_clip_region_checked (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_picture_clip_region_request_t xcb_out; + + xcb_out.picture = picture; + xcb_out.region = region; + xcb_out.x_origin = x_origin; + xcb_out.y_origin = y_origin; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_picture_clip_region (xcb_connection_t *c, + xcb_render_picture_t picture, + xcb_xfixes_region_t region, + int16_t x_origin, + int16_t y_origin) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_PICTURE_CLIP_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_picture_clip_region_request_t xcb_out; + + xcb_out.picture = picture; + xcb_out.region = region; + xcb_out.x_origin = x_origin; + xcb_out.y_origin = y_origin; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_xfixes_set_cursor_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_set_cursor_name_request_t *_aux = (xcb_xfixes_set_cursor_name_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_set_cursor_name_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_xfixes_set_cursor_name_checked (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CURSOR_NAME, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_cursor_name_request_t xcb_out; + + xcb_out.cursor = cursor; + xcb_out.nbytes = nbytes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = nbytes * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor, + uint16_t nbytes, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CURSOR_NAME, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_cursor_name_request_t xcb_out; + + xcb_out.cursor = cursor; + xcb_out.nbytes = nbytes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = nbytes * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +char * +xcb_xfixes_set_cursor_name_name (const xcb_xfixes_set_cursor_name_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_xfixes_set_cursor_name_name_length (const xcb_xfixes_set_cursor_name_request_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_set_cursor_name_name_end (const xcb_xfixes_set_cursor_name_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +int +xcb_xfixes_get_cursor_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_name_reply_t *_aux = (xcb_xfixes_get_cursor_name_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_name_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_xfixes_get_cursor_name_cookie_t +xcb_xfixes_get_cursor_name (xcb_connection_t *c, + xcb_cursor_t cursor) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_NAME, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_name_cookie_t xcb_ret; + xcb_xfixes_get_cursor_name_request_t xcb_out; + + xcb_out.cursor = cursor; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_cursor_name_cookie_t +xcb_xfixes_get_cursor_name_unchecked (xcb_connection_t *c, + xcb_cursor_t cursor) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_NAME, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_name_cookie_t xcb_ret; + xcb_xfixes_get_cursor_name_request_t xcb_out; + + xcb_out.cursor = cursor; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +char * +xcb_xfixes_get_cursor_name_name (const xcb_xfixes_get_cursor_name_reply_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_xfixes_get_cursor_name_name_length (const xcb_xfixes_get_cursor_name_reply_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_name_name_end (const xcb_xfixes_get_cursor_name_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_xfixes_get_cursor_name_reply_t * +xcb_xfixes_get_cursor_name_reply (xcb_connection_t *c, + xcb_xfixes_get_cursor_name_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_get_cursor_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +int +xcb_xfixes_get_cursor_image_and_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_get_cursor_image_and_name_reply_t *_aux = (xcb_xfixes_get_cursor_image_and_name_reply_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_get_cursor_image_and_name_reply_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* cursor_image */ + xcb_block_len += (_aux->width * _aux->height) * sizeof(uint32_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint32_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_xfixes_get_cursor_image_and_name_cookie_t +xcb_xfixes_get_cursor_image_and_name (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_image_and_name_cookie_t xcb_ret; + xcb_xfixes_get_cursor_image_and_name_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_cursor_image_and_name_cookie_t +xcb_xfixes_get_cursor_image_and_name_unchecked (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CURSOR_IMAGE_AND_NAME, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_cursor_image_and_name_cookie_t xcb_ret; + xcb_xfixes_get_cursor_image_and_name_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint32_t * +xcb_xfixes_get_cursor_image_and_name_cursor_image (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + return (uint32_t *) (R + 1); +} + +int +xcb_xfixes_get_cursor_image_and_name_cursor_image_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + return (R->width * R->height); +} + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_image_and_name_cursor_image_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint32_t *) (R + 1)) + ((R->width * R->height)); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +char * +xcb_xfixes_get_cursor_image_and_name_name (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R); + return (char *) ((char *) prev.data + XCB_TYPE_PAD(char, prev.index) + 0); +} + +int +xcb_xfixes_get_cursor_image_and_name_name_length (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_get_cursor_image_and_name_name_end (const xcb_xfixes_get_cursor_image_and_name_reply_t *R) +{ + xcb_generic_iterator_t i; + xcb_generic_iterator_t prev = xcb_xfixes_get_cursor_image_and_name_cursor_image_end(R); + i.data = ((char *) ((char*) prev.data + XCB_TYPE_PAD(char, prev.index))) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_xfixes_get_cursor_image_and_name_reply_t * +xcb_xfixes_get_cursor_image_and_name_reply (xcb_connection_t *c, + xcb_xfixes_get_cursor_image_and_name_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_get_cursor_image_and_name_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + +xcb_void_cookie_t +xcb_xfixes_change_cursor_checked (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_cursor_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_change_cursor (xcb_connection_t *c, + xcb_cursor_t source, + xcb_cursor_t destination) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_cursor_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +int +xcb_xfixes_change_cursor_by_name_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_change_cursor_by_name_request_t *_aux = (xcb_xfixes_change_cursor_by_name_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_change_cursor_by_name_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* name */ + xcb_block_len += _aux->nbytes * sizeof(char); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(char); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_xfixes_change_cursor_by_name_checked (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_cursor_by_name_request_t xcb_out; + + xcb_out.src = src; + xcb_out.nbytes = nbytes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = nbytes * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_change_cursor_by_name (xcb_connection_t *c, + xcb_cursor_t src, + uint16_t nbytes, + const char *name) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CHANGE_CURSOR_BY_NAME, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_change_cursor_by_name_request_t xcb_out; + + xcb_out.src = src; + xcb_out.nbytes = nbytes; + memset(xcb_out.pad0, 0, 2); + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* char name */ + xcb_parts[4].iov_base = (char *) name; + xcb_parts[4].iov_len = nbytes * sizeof(char); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +char * +xcb_xfixes_change_cursor_by_name_name (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + return (char *) (R + 1); +} + +int +xcb_xfixes_change_cursor_by_name_name_length (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + return R->nbytes; +} + +xcb_generic_iterator_t +xcb_xfixes_change_cursor_by_name_name_end (const xcb_xfixes_change_cursor_by_name_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((char *) (R + 1)) + (R->nbytes); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_xfixes_expand_region_checked (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_EXPAND_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_expand_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + xcb_out.left = left; + xcb_out.right = right; + xcb_out.top = top; + xcb_out.bottom = bottom; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_expand_region (xcb_connection_t *c, + xcb_xfixes_region_t source, + xcb_xfixes_region_t destination, + uint16_t left, + uint16_t right, + uint16_t top, + uint16_t bottom) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_EXPAND_REGION, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_expand_region_request_t xcb_out; + + xcb_out.source = source; + xcb_out.destination = destination; + xcb_out.left = left; + xcb_out.right = right; + xcb_out.top = top; + xcb_out.bottom = bottom; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_hide_cursor_checked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_HIDE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_hide_cursor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_hide_cursor (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_HIDE_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_hide_cursor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_show_cursor_checked (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SHOW_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_show_cursor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_show_cursor (xcb_connection_t *c, + xcb_window_t window) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SHOW_CURSOR, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_show_cursor_request_t xcb_out; + + xcb_out.window = window; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +void +xcb_xfixes_barrier_next (xcb_xfixes_barrier_iterator_t *i) +{ + --i->rem; + ++i->data; + i->index += sizeof(xcb_xfixes_barrier_t); +} + +xcb_generic_iterator_t +xcb_xfixes_barrier_end (xcb_xfixes_barrier_iterator_t i) +{ + xcb_generic_iterator_t ret; + ret.data = i.data + i.rem; + ret.index = i.index + ((char *) ret.data - (char *) i.data); + ret.rem = 0; + return ret; +} + +int +xcb_xfixes_create_pointer_barrier_sizeof (const void *_buffer) +{ + char *xcb_tmp = (char *)_buffer; + const xcb_xfixes_create_pointer_barrier_request_t *_aux = (xcb_xfixes_create_pointer_barrier_request_t *)_buffer; + unsigned int xcb_buffer_len = 0; + unsigned int xcb_block_len = 0; + unsigned int xcb_pad = 0; + unsigned int xcb_align_to = 0; + + + xcb_block_len += sizeof(xcb_xfixes_create_pointer_barrier_request_t); + xcb_tmp += xcb_block_len; + xcb_buffer_len += xcb_block_len; + xcb_block_len = 0; + /* devices */ + xcb_block_len += _aux->num_devices * sizeof(uint16_t); + xcb_tmp += xcb_block_len; + xcb_align_to = ALIGNOF(uint16_t); + /* insert padding */ + xcb_pad = -xcb_block_len & (xcb_align_to - 1); + xcb_buffer_len += xcb_block_len + xcb_pad; + if (0 != xcb_pad) { + xcb_tmp += xcb_pad; + xcb_pad = 0; + } + xcb_block_len = 0; + + return xcb_buffer_len; +} + +xcb_void_cookie_t +xcb_xfixes_create_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_pointer_barrier_request_t xcb_out; + + xcb_out.barrier = barrier; + xcb_out.window = window; + xcb_out.x1 = x1; + xcb_out.y1 = y1; + xcb_out.x2 = x2; + xcb_out.y2 = y2; + xcb_out.directions = directions; + memset(xcb_out.pad0, 0, 2); + xcb_out.num_devices = num_devices; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint16_t devices */ + xcb_parts[4].iov_base = (char *) devices; + xcb_parts[4].iov_len = num_devices * sizeof(uint16_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_create_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier, + xcb_window_t window, + uint16_t x1, + uint16_t y1, + uint16_t x2, + uint16_t y2, + uint32_t directions, + uint16_t num_devices, + const uint16_t *devices) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 4, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_CREATE_POINTER_BARRIER, + .isvoid = 1 + }; + + struct iovec xcb_parts[6]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_create_pointer_barrier_request_t xcb_out; + + xcb_out.barrier = barrier; + xcb_out.window = window; + xcb_out.x1 = x1; + xcb_out.y1 = y1; + xcb_out.x2 = x2; + xcb_out.y2 = y2; + xcb_out.directions = directions; + memset(xcb_out.pad0, 0, 2); + xcb_out.num_devices = num_devices; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + /* uint16_t devices */ + xcb_parts[4].iov_base = (char *) devices; + xcb_parts[4].iov_len = num_devices * sizeof(uint16_t); + xcb_parts[5].iov_base = 0; + xcb_parts[5].iov_len = -xcb_parts[4].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +uint16_t * +xcb_xfixes_create_pointer_barrier_devices (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + return (uint16_t *) (R + 1); +} + +int +xcb_xfixes_create_pointer_barrier_devices_length (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + return R->num_devices; +} + +xcb_generic_iterator_t +xcb_xfixes_create_pointer_barrier_devices_end (const xcb_xfixes_create_pointer_barrier_request_t *R) +{ + xcb_generic_iterator_t i; + i.data = ((uint16_t *) (R + 1)) + (R->num_devices); + i.rem = 0; + i.index = (char *) i.data - (char *) R; + return i; +} + +xcb_void_cookie_t +xcb_xfixes_delete_pointer_barrier_checked (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_delete_pointer_barrier_request_t xcb_out; + + xcb_out.barrier = barrier; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_delete_pointer_barrier (xcb_connection_t *c, + xcb_xfixes_barrier_t barrier) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_DELETE_POINTER_BARRIER, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_delete_pointer_barrier_request_t xcb_out; + + xcb_out.barrier = barrier; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_client_disconnect_mode_checked (xcb_connection_t *c, + uint32_t disconnect_mode) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CLIENT_DISCONNECT_MODE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_client_disconnect_mode_request_t xcb_out; + + xcb_out.disconnect_mode = disconnect_mode; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_void_cookie_t +xcb_xfixes_set_client_disconnect_mode (xcb_connection_t *c, + uint32_t disconnect_mode) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_SET_CLIENT_DISCONNECT_MODE, + .isvoid = 1 + }; + + struct iovec xcb_parts[4]; + xcb_void_cookie_t xcb_ret; + xcb_xfixes_set_client_disconnect_mode_request_t xcb_out; + + xcb_out.disconnect_mode = disconnect_mode; + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_client_disconnect_mode_cookie_t +xcb_xfixes_get_client_disconnect_mode (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CLIENT_DISCONNECT_MODE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_client_disconnect_mode_cookie_t xcb_ret; + xcb_xfixes_get_client_disconnect_mode_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, XCB_REQUEST_CHECKED, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_client_disconnect_mode_cookie_t +xcb_xfixes_get_client_disconnect_mode_unchecked (xcb_connection_t *c) +{ + static const xcb_protocol_request_t xcb_req = { + .count = 2, + .ext = &xcb_xfixes_id, + .opcode = XCB_XFIXES_GET_CLIENT_DISCONNECT_MODE, + .isvoid = 0 + }; + + struct iovec xcb_parts[4]; + xcb_xfixes_get_client_disconnect_mode_cookie_t xcb_ret; + xcb_xfixes_get_client_disconnect_mode_request_t xcb_out; + + + xcb_parts[2].iov_base = (char *) &xcb_out; + xcb_parts[2].iov_len = sizeof(xcb_out); + xcb_parts[3].iov_base = 0; + xcb_parts[3].iov_len = -xcb_parts[2].iov_len & 3; + + xcb_ret.sequence = xcb_send_request(c, 0, xcb_parts + 2, &xcb_req); + return xcb_ret; +} + +xcb_xfixes_get_client_disconnect_mode_reply_t * +xcb_xfixes_get_client_disconnect_mode_reply (xcb_connection_t *c, + xcb_xfixes_get_client_disconnect_mode_cookie_t cookie /**< */, + xcb_generic_error_t **e) +{ + return (xcb_xfixes_get_client_disconnect_mode_reply_t *) xcb_wait_for_reply(c, cookie.sequence, e); +} + -- cgit v1.2.3