xcb_allow_events(3) XCB Requests xcb_allow_events(3)

NAME

xcb_allow_events - release queued events

SYNOPSIS

#include <xcb/xproto.h>

Request function

xcb_void_cookie_t xcb_allow_events(xcb_connection_t *conn,
uint8_t mode, xcb_timestamp_t time);

REQUEST ARGUMENTS

conn The XCB connection to X11.

mode One of the following values:

XCB_ALLOW_ASYNC_POINTER
For AsyncPointer, if the pointer is frozen by the
client, pointer event processing continues
normally. If the pointer is frozen twice by the
client on behalf of two separate grabs,
AsyncPointer thaws for both. AsyncPointer has no
effect if the pointer is not frozen by the
client, but the pointer need not be grabbed by
the client.

TODO: rewrite this in more understandable terms.

XCB_ALLOW_SYNC_POINTER
For SyncPointer, if the pointer is frozen and
actively grabbed by the client, pointer event
processing continues normally until the next
ButtonPress or ButtonRelease event is reported to
the client, at which time the pointer again
appears to freeze. However, if the reported event
causes the pointer grab to be released, then the
pointer does not freeze. SyncPointer has no
effect if the pointer is not frozen by the client
or if the pointer is not grabbed by the client.

XCB_ALLOW_REPLAY_POINTER
For ReplayPointer, if the pointer is actively
grabbed by the client and is frozen as the result
of an event having been sent to the client
(either from the activation of a GrabButton or
from a previous AllowEvents with mode SyncPointer
but not from a GrabPointer), then the pointer
grab is released and that event is completely
reprocessed, this time ignoring any passive grabs
at or above (towards the root) the grab-window of
the grab just released. The request has no effect
if the pointer is not grabbed by the client or if
the pointer is not frozen as the result of an
event.

XCB_ALLOW_ASYNC_KEYBOARD
For AsyncKeyboard, if the keyboard is frozen by
the client, keyboard event processing continues
normally. If the keyboard is frozen twice by the
client on behalf of two separate grabs,
AsyncKeyboard thaws for both. AsyncKeyboard has
no effect if the keyboard is not frozen by the
client, but the keyboard need not be grabbed by
the client.

XCB_ALLOW_SYNC_KEYBOARD
For SyncKeyboard, if the keyboard is frozen and
actively grabbed by the client, keyboard event
processing continues normally until the next
KeyPress or KeyRelease event is reported to the
client, at which time the keyboard again appears
to freeze. However, if the reported event causes
the keyboard grab to be released, then the
keyboard does not freeze. SyncKeyboard has no
effect if the keyboard is not frozen by the
client or if the keyboard is not grabbed by the
client.

XCB_ALLOW_REPLAY_KEYBOARD
For ReplayKeyboard, if the keyboard is actively
grabbed by the client and is frozen as the result
of an event having been sent to the client
(either from the activation of a GrabKey or from
a previous AllowEvents with mode SyncKeyboard but
not from a GrabKeyboard), then the keyboard grab
is released and that event is completely
reprocessed, this time ignoring any passive grabs
at or above (towards the root) the grab-window of
the grab just released. The request has no effect
if the keyboard is not grabbed by the client or
if the keyboard is not frozen as the result of an
event.

XCB_ALLOW_ASYNC_BOTH
For AsyncBoth, if the pointer and the keyboard
are frozen by the client, event processing for
both devices continues normally. If a device is
frozen twice by the client on behalf of two
separate grabs, AsyncBoth thaws for both.
AsyncBoth has no effect unless both pointer and
keyboard are frozen by the client.

XCB_ALLOW_SYNC_BOTH
For SyncBoth, if both pointer and keyboard are
frozen by the client, event processing (for both
devices) continues normally until the next
ButtonPress, ButtonRelease, KeyPress, or
KeyRelease event is reported to the client for a
grabbed device (button event for the pointer, key
event for the keyboard), at which time the
devices again appear to freeze. However, if the
reported event causes the grab to be released,
then the devices do not freeze (but if the other
device is still grabbed, then a subsequent event
for it will still cause both devices to freeze).
SyncBoth has no effect unless both pointer and
keyboard are frozen by the client. If the pointer
or keyboard is frozen twice by the client on
behalf of two separate grabs, SyncBoth thaws for
both (but a subsequent freeze for SyncBoth will
only freeze each device once).


time Timestamp to avoid race conditions when running X over the
network.

The special value XCB_CURRENT_TIME will be replaced with
the current server time.

DESCRIPTION

Releases queued events if the client has caused a device
(pointer/keyboard) to freeze due to grabbing it actively. This
request has no effect if time is earlier than the last-grab time of
the most recent active grab for this client or if time is later than
the current X server time.

RETURN VALUE

Returns an xcb_void_cookie_t. Errors (if any) have to be handled in
the event loop.

If you want to handle errors directly with xcb_request_check instead,
use xcb_allow_events_checked. See xcb-requests(3) for details.

ERRORS

xcb_value_error_t
You specified an invalid mode.

SEE ALSO

xcb-requests(3)

AUTHOR

Generated from xproto.xml. Contact xcb@lists.freedesktop.org for
corrections and improvements.

X Version 11 libxcb 1.16.1 xcb_allow_events(3)