X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fxcb.h;h=3e61ebdf974f3f20589d28b4f1ce932613949cbe;hb=2415c11dec5e5adb0c17f98aa52fbb371a4f8f23;hp=4c3e0794c9264f1923911e28d142df94280bec0b;hpb=8eba8690adac2c4425f4cac490c77f9f3b1da6f7;p=free-sw%2Fxcb%2Flibxcb diff --git a/src/xcb.h b/src/xcb.h index 4c3e079..3e61ebd 100644 --- a/src/xcb.h +++ b/src/xcb.h @@ -35,7 +35,11 @@ #include #endif +#ifndef _WIN32 #include +#else +#include "xcb_windefs.h" +#endif #include @@ -115,6 +119,23 @@ typedef struct { uint32_t full_sequence; /**< full sequence */ } xcb_generic_event_t; +/** + * @brief GE event + * + * An event as sent by the XGE extension. The length field specifies the + * number of 4-byte blocks trailing the struct. + */ +typedef struct { + uint8_t response_type; /**< Type of the response */ + uint8_t pad0; /**< Padding */ + uint16_t sequence; /**< Sequence number */ + uint32_t length; + uint16_t event_type; + uint16_t pad1; + uint32_t pad[5]; /**< Padding */ + uint32_t full_sequence; /**< full sequence */ +} xcb_ge_event_t; + /** * @brief Generic error. * @@ -124,7 +145,11 @@ typedef struct { uint8_t response_type; /**< Type of the response */ uint8_t error_code; /**< Error code */ uint16_t sequence; /**< Sequence number */ - uint32_t pad[7]; /**< Padding */ + uint32_t resource_id; /** < Resource ID for requests with side effects only */ + uint16_t minor_code; /** < Minor opcode of the failed request */ + uint8_t major_code; /** < Major opcode of the failed request */ + uint8_t pad0; + uint32_t pad[5]; /**< Padding */ uint32_t full_sequence; /**< full sequence */ } xcb_generic_error_t; @@ -183,8 +208,7 @@ typedef struct xcb_auth_info_t { int xcb_flush(xcb_connection_t *c); /** - * @brief Returns the maximum request length field from the connection - * setup data. + * @brief Returns the maximum request length that this server accepts. * @param c: The connection to the X server. * @return The maximum request length field. * @@ -200,6 +224,25 @@ int xcb_flush(xcb_connection_t *c); */ uint32_t xcb_get_maximum_request_length(xcb_connection_t *c); +/** + * @brief Prefetch the maximum request length without blocking. + * @param c: The connection to the X server. + * + * Without blocking, does as much work as possible toward computing + * the maximum request length accepted by the X server. + * + * Invoking this function may cause a call to xcb_big_requests_enable, + * but will not block waiting for the reply. + * xcb_get_maximum_request_length will return the prefetched data + * after possibly blocking while the reply is retrieved. + * + * Note that in order for this function to be fully non-blocking, the + * application must previously have called + * xcb_prefetch_extension_data(c, &xcb_big_requests_id) and the reply + * must have already arrived. + */ +void xcb_prefetch_maximum_request_length(xcb_connection_t *c); + /* xcb_in.c */ @@ -228,6 +271,41 @@ xcb_generic_event_t *xcb_wait_for_event(xcb_connection_t *c); */ xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c); +/** + * @brief Returns the next event or error that precedes the given request. + * @param c: The connection to the X server. + * @param request: The limiting sequence number. + * @return The next event from the server. + * + * Returns the next event or error with a sequence number less than or + * equal to the given sequence number, or returns NULL if no such event can + * ever arrive. Blocks until either a suitable event or error arrive, or a + * response arrives that proves no such event is coming, or an I/O error + * occurs. + * + * After processing a request, the X server sends responses in a specific + * order. First come any events that the request generated, then any + * replies for the request, then the error response if there is one. After + * that, the server may spontaneously send more events with the same + * sequence number, which are not related to that request. + * + * This function will always return events from the pre-reply phase of the + * specified request. It may also return events from the unrelated + * post-reply stream, as long as they have the same sequence number. + * + * This function is useful for callers that need to process responses in + * wire-order. + * + * Implementation note: You cannot currently use this function to ensure + * that you process responses in exactly wire-order, because depending on + * the sequence of calls you make and the timing of server responses, + * post-reply events with the same sequence number may be returned as part + * of the pre-reply event stream, even though they were separated by a + * reply or error. In practice this kind of error is unlikely to matter, + * but it may be fixed in the future. + */ +xcb_generic_event_t *xcb_wait_for_event_until(xcb_connection_t *c, unsigned int request); + /** * @brief Return the error for a request, or NULL if none can ever arrive. * @param c: The connection to the X server. @@ -246,6 +324,22 @@ xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c); */ xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie); +/** + * @brief Discards the reply for a request. + * @param c: The connection to the X server. + * @param sequence: The request sequence number from a cookie. + * + * Discards the reply for a request. Additionally, any error generated + * by the request is also discarded (unless it was an _unchecked request + * and the error has already arrived). + * + * This function will not block even if the reply is not yet available. + * + * Note that the sequence really does have to come from an xcb cookie; + * this function is not designed to operate on socket-handoff replies. + */ +void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence); + /* xcb_ext.c */