/** Get or set global key bindings.
* This binding will be available when you'll press keys on root window.
* \param L The Lua VM state.
* \return The number of element pushed on stack.
* \luastack
* \lparam An array of key bindings objects, or nothing.
* \lreturn The array of key bindings objects of this client.
*/
static int
luaA_root_keys(lua_State *L)
{
if(lua_gettop(L) == 1)
{
luaA_checktable(L, 1);
foreach(key, globalconf.keys)
luaA_object_unref(globalconf.L, *key);
key_array_wipe(&globalconf.keys);
key_array_init(&globalconf.keys);
lua_pushnil(L);
while(lua_next(L, 1))
key_array_append(&globalconf.keys, luaA_object_ref_class(L, -1, &key_class));
xcb_screen_t *s = globalconf.screen;
xcb_ungrab_key(globalconf.connection, XCB_GRAB_ANY, s->root, XCB_BUTTON_MASK_ANY);
xwindow_grabkeys(s->root, &globalconf.keys);
return 1;
}
lua_createtable(L, globalconf.keys.len, 0);
for(int i = 0; i < globalconf.keys.len; i++)
{
luaA_object_push(L, globalconf.keys.tab[i]);
lua_rawseti(L, -2, i + 1);
}
return 1;
}
/**
* g_paste_keybinding_unbind:
* @self: a #GPasteKeybinding instance
*
* Deactivate the keybinding
*
* Returns:
*/
G_PASTE_VISIBLE void
g_paste_keybinding_deactivate (GPasteKeybinding *self)
{
g_return_if_fail (G_PASTE_IS_KEYBINDING (self));
GPasteKeybindingPrivate *priv = self->priv;
g_return_if_fail (priv->active);
GPasteXcbWrapper *xcb_wrapper = priv->xcb_wrapper;
for (xcb_keycode_t *keycode = priv->keycodes; *keycode; ++keycode)
{
xcb_screen_t *screen = (xcb_screen_t *) g_paste_xcb_wrapper_get_screen (xcb_wrapper);
xcb_ungrab_key ((xcb_connection_t *) g_paste_xcb_wrapper_get_connection (xcb_wrapper),
*keycode,
screen->root,
priv->modifiers);
}
g_free (priv->keycodes);
priv->active = FALSE;
}
void ungrab(void)
{
PUTS("ungrab");
xcb_ungrab_key(dpy, XCB_GRAB_ANY, root, XCB_BUTTON_MASK_ANY);
xcb_ungrab_button(dpy, XCB_BUTTON_INDEX_ANY, root, XCB_MOD_MASK_ANY);
xcb_flush(dpy);
grabbed = false;
}
void
xwindow_grabkeys(xcb_window_t win, key_array_t *keys)
{
/* Ungrab everything first */
xcb_ungrab_key(globalconf.connection, XCB_GRAB_ANY, win, XCB_BUTTON_MASK_ANY);
foreach(k, *keys)
xwindow_grabkey(win, *k);
}
static void Unregister( intf_thread_t *p_intf )
{
intf_sys_t *p_sys = p_intf->p_sys;
for( int i = 0; i < p_sys->i_map; i++ )
{
const hotkey_mapping_t *p_map = &p_sys->p_map[i];
xcb_ungrab_key( p_sys->p_connection, p_map->i_x11, p_sys->root, p_map->i_modifier );
}
}
/** Ungrab key on the root windows.
* \param k The keybinding.
*/
static void
window_root_ungrabkey(keybinding_t *k)
{
int phys_screen = 0;
int nscreen = xcb_setup_roots_length(xcb_get_setup(globalconf.connection));
xcb_screen_t *s;
xcb_keycode_t kc;
if((kc = k->keycode)
|| (k->keysym && (kc = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym))))
do
{
s = xutil_screen_get(globalconf.connection, phys_screen);
xcb_ungrab_key(globalconf.connection, kc, s->root,
k->mod);
xcb_ungrab_key(globalconf.connection, kc, s->root,
k->mod | XCB_MOD_MASK_LOCK);
xcb_ungrab_key(globalconf.connection, kc, s->root,
k->mod | globalconf.numlockmask);
xcb_ungrab_key(globalconf.connection, kc, s->root,
k->mod | globalconf.numlockmask | XCB_MOD_MASK_LOCK);
phys_screen++;
} while(phys_screen < nscreen);
}
bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods)
{
xcb_connection_t *xcbConnection = QX11Info::connection();
QList<xcb_void_cookie_t> xcbCookies;
for (quint32 maskMods : maskModifiers) {
xcb_ungrab_key(xcbConnection, nativeKey, QX11Info::appRootWindow(), nativeMods | maskMods);
}
bool failed = false;
for (xcb_void_cookie_t cookie : xcbCookies) {
QScopedPointer<xcb_generic_error_t, QScopedPointerPodDeleter> error(xcb_request_check(xcbConnection, cookie));
failed = !error.isNull();
}
return !failed;
}
// TODO DOESNT WORK
void keys_grab(Key *keys, int length)
{
xcb_keycode_t *keycode;
unsigned int modifiers[] = { 0, XCB_MOD_MASK_LOCK, XCB_MOD_MASK_LOCK };
xcb_ungrab_key(SWM.xcb_conn, XCB_GRAB_ANY, SWM.root_win, XCB_MOD_MASK_ANY);
for (unsigned int i=0; i < length; i++)
{
keycode = xcb_get_keycodes(keys[i].keysym);
for (unsigned int k=0; keycode[k] != XCB_NO_SYMBOL; k++)
{
for (unsigned int m=0; m < LENGTH(modifiers); m++)
{
xcb_grab_key(SWM.xcb_conn, 1, SWM.root_win, keys[i].mod | modifiers[m], keycode[k], XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
}
}
free(keycode);
}
}
static
int init_key() {
unsigned int i;
const struct key_t *k;
xcb_keycode_t key;
nil_.key_syms = xcb_key_symbols_alloc(nil_.con);
update_keys_mask();
xcb_ungrab_key(nil_.con, XCB_GRAB_ANY, nil_.scr->root, XCB_MOD_MASK_ANY);
for (i = 0; i < cfg_.keys_len; ++i) {
k = &cfg_.keys[i];
key = get_keycode(k->keysym);
if (key == 0) {
continue;
}
/* grap key in all combinations of NUMLOCK and CAPSLOCK*/
GRAB_ALL_MOD_(GRAB_KEY_, nil_.scr->root, key, k->mod);
}
return 0;
}
void MainWindow::setHotKey(const QKeySequence& hotKey_) {
// platform-specific code for global key grabbing
#ifdef WIN32
UINT i_vk, i_mod = 0;
if(!hotKey.isEmpty()) {
// disable previous hotkey
UnregisterHotKey(NULL, 10);
}
hotKey = hotKey_;
nativeFilter.setHotKey(hotKey);
settings.setValue("hotkey", hotKey);
if(hotKey.isEmpty()) return;
int key = hotKey[0];
if(key & Qt::ALT) i_mod |= MOD_ALT;
if(key & Qt::CTRL) i_mod |= MOD_CONTROL;
if(key & Qt::SHIFT) i_mod |= MOD_SHIFT;
key = key & ~(Qt::ALT | Qt::CTRL | Qt::SHIFT | Qt::META);
#ifndef VK_VOLUME_DOWN
#define VK_VOLUME_DOWN 0xAE
#define VK_VOLUME_UP 0xAF
#endif
#ifndef VK_MEDIA_NEXT_TRACK
#define VK_MEDIA_NEXT_TRACK 0xB0
#define VK_MEDIA_PREV_TRACK 0xB1
#define VK_MEDIA_STOP 0xB2
#define VK_MEDIA_PLAY_PAUSE 0xB3
#endif
#ifndef VK_PAGEUP
#define VK_PAGEUP 0x21
#define VK_PAGEDOWN 0x22
#endif
switch(key) {
case Qt::Key_Left: i_vk = VK_LEFT; break;
case Qt::Key_Right: i_vk = VK_RIGHT; break;
case Qt::Key_Up: i_vk = VK_UP; break;
case Qt::Key_Down: i_vk = VK_DOWN; break;
case Qt::Key_Space: i_vk = VK_SPACE; break;
case Qt::Key_Escape: i_vk = VK_ESCAPE; break;
case Qt::Key_Enter: i_vk = VK_RETURN; break;
case Qt::Key_Return: i_vk = VK_RETURN; break;
case Qt::Key_F1: i_vk = VK_F1; break;
case Qt::Key_F2: i_vk = VK_F2; break;
case Qt::Key_F3: i_vk = VK_F3; break;
case Qt::Key_F4: i_vk = VK_F4; break;
case Qt::Key_F5: i_vk = VK_F5; break;
case Qt::Key_F6: i_vk = VK_F6; break;
case Qt::Key_F7: i_vk = VK_F7; break;
case Qt::Key_F8: i_vk = VK_F8; break;
case Qt::Key_F9: i_vk = VK_F9; break;
case Qt::Key_F10: i_vk = VK_F10; break;
case Qt::Key_F11: i_vk = VK_F11; break;
case Qt::Key_F12: i_vk = VK_F12; break;
case Qt::Key_PageUp: i_vk = VK_PAGEUP; break;
case Qt::Key_PageDown: i_vk = VK_PAGEDOWN; break;
case Qt::Key_Home: i_vk = VK_HOME; break;
case Qt::Key_End: i_vk = VK_END; break;
case Qt::Key_Insert: i_vk = VK_INSERT; break;
case Qt::Key_Delete: i_vk = VK_DELETE; break;
case Qt::Key_VolumeDown: i_vk = VK_VOLUME_DOWN; break;
case Qt::Key_VolumeUp: i_vk = VK_VOLUME_UP; break;
case Qt::Key_MediaTogglePlayPause: i_vk = VK_MEDIA_PLAY_PAUSE; break;
case Qt::Key_MediaStop: i_vk = VK_MEDIA_STOP; break;
case Qt::Key_MediaPrevious: i_vk = VK_MEDIA_PREV_TRACK; break;
case Qt::Key_MediaNext: i_vk = VK_MEDIA_NEXT_TRACK; break;
default:
i_vk = toupper( key );
break;
}
if(!RegisterHotKey(NULL, 10, i_mod, i_vk)) {
hotKey = QKeySequence();
nativeFilter.setHotKey(hotKey);
settings.setValue("hotkey", hotKey);
QMessageBox::warning(this, "Key binding failed", "Binding global hotkey failed.");
}
#elif LINUX
auto platform = qApp->platformNativeInterface();
xcb_connection_t *c = static_cast<xcb_connection_t*>(platform->nativeResourceForWindow("connection", 0));
xcb_key_symbols_t *keysyms = xcb_key_symbols_alloc(c);
if(!hotKey.isEmpty()) {
// remove previous bindings from all screens
xcb_screen_iterator_t iter;
iter = xcb_setup_roots_iterator (xcb_get_setup (c));
for (; iter.rem; xcb_screen_next (&iter)) {
xcb_ungrab_key(c, XCB_GRAB_ANY, iter.data->root, XCB_MOD_MASK_ANY);
}
}
hotKey = hotKey_;
nativeFilter.setHotKey(hotKey);
settings.setValue("hotkey", hotKey);
if(hotKey.isEmpty()) return;
xcb_keysym_t keysym = GetX11Key(hotKey[0]);
xcb_keycode_t *keycodes = xcb_key_symbols_get_keycode(keysyms, keysym), keycode;
if(!keycodes) {
hotKey = QKeySequence();
nativeFilter.setHotKey(hotKey);
settings.setValue("hotkey", hotKey);
QMessageBox::warning(this, "Key binding failed", "Binding global hotkey failed.");
free(keysyms);
return;
}
// add bindings for all screens
xcb_screen_iterator_t iter;
iter = xcb_setup_roots_iterator (xcb_get_setup (c));
bool any_failed = false;
for (; iter.rem; xcb_screen_next (&iter)) {
int i = 0;
while(keycodes[i] != XCB_NO_SYMBOL) {
keycode = keycodes[i];
for(auto modifier : GetX11Modifier(c, keysyms, hotKey[0])) {
auto cookie = xcb_grab_key_checked(c, true, iter.data->root,
modifier, keycode, XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_SYNC);
if(xcb_request_check(c, cookie)) {
any_failed = true;
}
}
i += 1;
}
}
if(any_failed) {
QMessageBox::warning(this, "Key binding warning",
"Warning: Global hotkey binding problem detected. Some other program might have a conflicting "
"key binding. If the hotkey doesn't work, try closing some programs or using a different hotkey.");
}
free(keysyms);
free(keycodes);
#endif // WIN32 or LINUX
}
void UGlobalHotkeys::unregLinuxHotkey(size_t id)
{
UHotkeyData data = Registered.take(id);
xcb_ungrab_key(X11Connection, data.keyCode, X11Wid, data.mods);
xcb_ungrab_key(X11Connection, data.keyCode, X11Wid, data.mods | XCB_MOD_MASK_2);
}
