void X11WindowedBackend::grabKeyboard(xcb_timestamp_t time)
{
const bool oldState = m_keyboardGrabbed;
if (m_keyboardGrabbed) {
xcb_ungrab_keyboard(m_connection, time);
xcb_ungrab_pointer(m_connection, time);
m_keyboardGrabbed = false;
} else {
const auto c = xcb_grab_keyboard_unchecked(m_connection, false, window(), time,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
ScopedCPointer<xcb_grab_keyboard_reply_t> grab(xcb_grab_keyboard_reply(m_connection, c, nullptr));
if (grab.isNull()) {
return;
}
if (grab->status == XCB_GRAB_STATUS_SUCCESS) {
const auto c = xcb_grab_pointer_unchecked(m_connection, false, window(),
XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
XCB_EVENT_MASK_POINTER_MOTION |
XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
window(), XCB_CURSOR_NONE, time);
ScopedCPointer<xcb_grab_pointer_reply_t> grab(xcb_grab_pointer_reply(m_connection, c, nullptr));
if (grab.isNull() || grab->status != XCB_GRAB_STATUS_SUCCESS) {
xcb_ungrab_keyboard(m_connection, time);
return;
}
m_keyboardGrabbed = true;
}
}
if (oldState != m_keyboardGrabbed) {
updateWindowTitle();
xcb_flush(m_connection);
}
}
/** Stop grabbing the keyboard.
* \param L The Lua VM state.
* \return The number of elements pushed on stack.
*/
int
luaA_keygrabber_stop(lua_State *L)
{
xcb_ungrab_keyboard(globalconf.connection, XCB_CURRENT_TIME);
luaA_unregister(L, &globalconf.keygrabber);
return 0;
}
static
void cleanup() {
if (nil_.key_syms) {
xcb_key_symbols_free(nil_.key_syms);
}
if (nil_.font.id) {
xcb_close_font(nil_.con, nil_.font.id);
}
if (nil_.cursor[CURSOR_NORMAL]) {
xcb_free_cursor(nil_.con, nil_.cursor[CURSOR_NORMAL]);
}
if (nil_.cursor[CURSOR_MOVE]
&& (nil_.cursor[CURSOR_MOVE] != nil_.cursor[CURSOR_NORMAL])) {
xcb_free_cursor(nil_.con, nil_.cursor[CURSOR_MOVE]);
}
if (nil_.cursor[CURSOR_RESIZE]
&& (nil_.cursor[CURSOR_RESIZE] != nil_.cursor[CURSOR_NORMAL])) {
xcb_free_cursor(nil_.con, nil_.cursor[CURSOR_RESIZE]);
}
if (bar_.win) {
xcb_destroy_window(nil_.con, bar_.win);
}
xcb_ungrab_keyboard(nil_.con, XCB_TIME_CURRENT_TIME);
xcb_destroy_subwindows(nil_.con, nil_.scr->root);
xcb_flush(nil_.con);
xcb_disconnect(nil_.con);
if (nil_.ws) {
free(nil_.ws);
}
}
void ungrabXKeyboard()
{
if (!keyboard_grabbed) {
// grabXKeyboard() may fail sometimes, so don't fail, but at least warn anyway
qCDebug(KWIN_CORE) << "ungrabXKeyboard() called but keyboard not grabbed!";
}
keyboard_grabbed = false;
xcb_ungrab_keyboard(connection(), XCB_TIME_CURRENT_TIME);
}
/**
* This app grabs the keyboard from X.
* It is used from ksldtest to verify we report if grabbing failed when the keyboard has been grabbed by another
* X Client. It needs to be another application, otherwise the grab cannot fail.
**/
int main(int argc, char **argv)
{
QCoreApplication app(argc, argv);
// connect to xcb
int screen = 0;
xcb_connection_t *c = xcb_connect(nullptr, &screen);
Q_ASSERT(c);
xcb_grab_keyboard(c, 1, rootWindow(c, screen), XCB_CURRENT_TIME, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
xcb_flush(c);
const int exitCode = app.exec();
xcb_ungrab_keyboard(c, XCB_CURRENT_TIME);
xcb_flush(c);
xcb_disconnect(c);
return exitCode;
}
static void
ephyrProcessKeyRelease(xcb_generic_event_t *xev)
{
xcb_connection_t *conn = hostx_get_xcbconn();
xcb_key_release_event_t *key = (xcb_key_release_event_t *)xev;
static xcb_key_symbols_t *keysyms;
static int grabbed_screen = -1;
int mod1_down = ephyrUpdateGrabModifierState(key->state);
if (!keysyms)
keysyms = xcb_key_symbols_alloc(conn);
if (!EphyrWantNoHostGrab &&
(((xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Shift_L
|| xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Shift_R)
&& (key->state & XCB_MOD_MASK_CONTROL)) ||
((xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Control_L
|| xcb_key_symbols_get_keysym(keysyms, key->detail, 0) == XK_Control_R)
&& (key->state & XCB_MOD_MASK_SHIFT)))) {
KdScreenInfo *screen = screen_from_window(key->event);
EphyrScrPriv *scrpriv = screen->driver;
if (grabbed_screen != -1) {
xcb_ungrab_keyboard(conn, XCB_TIME_CURRENT_TIME);
xcb_ungrab_pointer(conn, XCB_TIME_CURRENT_TIME);
grabbed_screen = -1;
hostx_set_win_title(screen,
"(ctrl+shift grabs mouse and keyboard)");
}
else if (!mod1_down) {
/* Attempt grab */
xcb_grab_keyboard_cookie_t kbgrabc =
xcb_grab_keyboard(conn,
TRUE,
scrpriv->win,
XCB_TIME_CURRENT_TIME,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC);
xcb_grab_keyboard_reply_t *kbgrabr;
xcb_grab_pointer_cookie_t pgrabc =
xcb_grab_pointer(conn,
TRUE,
scrpriv->win,
0,
XCB_GRAB_MODE_ASYNC,
XCB_GRAB_MODE_ASYNC,
scrpriv->win,
XCB_NONE,
XCB_TIME_CURRENT_TIME);
xcb_grab_pointer_reply_t *pgrabr;
kbgrabr = xcb_grab_keyboard_reply(conn, kbgrabc, NULL);
if (!kbgrabr || kbgrabr->status != XCB_GRAB_STATUS_SUCCESS) {
xcb_discard_reply(conn, pgrabc.sequence);
xcb_ungrab_pointer(conn, XCB_TIME_CURRENT_TIME);
} else {
pgrabr = xcb_grab_pointer_reply(conn, pgrabc, NULL);
if (!pgrabr || pgrabr->status != XCB_GRAB_STATUS_SUCCESS)
{
xcb_ungrab_keyboard(conn,
XCB_TIME_CURRENT_TIME);
} else {
grabbed_screen = scrpriv->mynum;
hostx_set_win_title
(screen,
"(ctrl+shift releases mouse and keyboard)");
}
}
}
}
if (!ephyrKbd ||
!((EphyrKbdPrivate *) ephyrKbd->driverPrivate)->enabled) {
return;
}
/* Still send the release event even if above has happened server
* will get confused with just an up event. Maybe it would be
* better to just block shift+ctrls getting to kdrive all
* together.
*/
ephyrUpdateModifierState(key->state);
KdEnqueueKeyboardEvent(ephyrKbd, key->detail, TRUE);
}
void release_keyboard ( void )
{
xcb_ungrab_keyboard ( xcb->connection, XCB_CURRENT_TIME );
}
