void ungrab_key (int key_code) { GdkWindow *root=gdk_get_default_root_window(); gdk_error_trap_push (); XUngrabKey (GDK_DISPLAY (), key_code, AnyModifier, (GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY()))); XUngrabKey (GDK_DISPLAY (), AnyKey, AnyModifier, (GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY()))); gdk_flush (); if (gdk_error_trap_pop ()) { gchar *error; gchar *key; key=g_strdup_printf ("%s",(XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (), key_code, 0)) != NULL)? XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (),key_code, 0)): g_strdup_printf ("%d",key_code)); error = g_strdup_printf (_("It seems that another application already has" " access to the multimedia keys.\n" "Key %s couldn't be bound.\n" "Is another daemon already running ?\n"), key); show_error(error); printf("[Sven][ERROR]:%s",error); g_free (key); g_free (error); } }
void handle_keypress_event(XEvent * e) { XEvent event; XGrabKey(display, AnyKey, AnyModifier, root, True, GrabModeAsync, GrabModeAsync); XMaskEvent (display, KeyPressMask, &event); XDefineCursor(display, selected, (XCreateFontCursor(display, CURSOR))); unsigned int key = XLookupKeysym((XKeyEvent *) &event, 0); if (key >= '0' && key <= '9') { XUngrabKey(display, AnyKey, AnyModifier, root); grab_keyboard(); select_window(key - '0'); return; } switch (key) { case KEY_TERMINAL: spawn(TERMINAL); break; case KEY_MENU: spawn(MENU); break; case KEY_STATUS: echo_output(STATUS); break; case KEY_WINLIST: if(TIMEOUT > 0) { list_windows(); } break; case KEY_KILL: XDestroyWindow(display, selected); selected = root; break; case KEY_PREV: if(get_prev_window() != -1){ select_window(get_prev_window()); } else { message("Can't access previous window!"); } break; case KEY_NEXT: if(get_next_window() != -1) { select_window(get_next_window()); } else { message("Can't access next window!"); } break; default: message("Key \"%c\" is unbound!", (char)key); } XUngrabKey(display, AnyKey, AnyModifier, root); grab_keyboard(); XSetInputFocus (display, selected, RevertToParent, CurrentTime); }
static void ungrabkey(Key *k) { XUngrabKey(display, k->key, k->mod, scr.root.xid); XUngrabKey(display, k->key, k->mod | LockMask, scr.root.xid); if(numlock_mask) { XUngrabKey(display, k->key, k->mod | numlock_mask, scr.root.xid); XUngrabKey(display, k->key, k->mod | numlock_mask | LockMask, scr.root.xid); } }
bool GlobalHotImpl::unregister_hot(quint32 native_key, quint32 native_mods) { Display* display = QX11Info::display(); Window window = QX11Info::appRootWindow(); hot_error = false; orig_x_err_handler = XSetErrorHandler(hot_x_err_handler); XUngrabKey(display, native_key, native_mods, window); XUngrabKey(display, native_key, native_mods | Mod2Mask, window); // allow numlock XSync(display, False); XSetErrorHandler(orig_x_err_handler); return !hot_error; }
bool QxtGlobalShortcutPrivate::unregisterShortcut(quint32 nativeKey, quint32 nativeMods) { Display* display = QX11Info::display(); Window window = QX11Info::appRootWindow(); error = false; original_x_errhandler = XSetErrorHandler(qxt_x_errhandler); XUngrabKey(display, nativeKey, nativeMods, window); XUngrabKey(display, nativeKey, nativeMods | Mod2Mask, window); // allow numlock XSync(display, False); XSetErrorHandler(original_x_errhandler); return !error; }
void grab_modifier_keys(Window window, int is_grab) { int i, k = 0; XModifierKeymap *modmap = XGetModifierMapping (main_window->display); for (i = 0; i < 8; i++) { int j; for (j = 0; j < modmap->max_keypermod; j++) { // Dirty hack for using Shift /*and Ctrl*/ on xneur if ((i == 0)/* || (i == 2)*/) { k++; continue; } if (modmap->modifiermap[k]) { /* int keysyms_per_keycode_return; KeySym *keysym = XGetKeyboardMapping(main_window->display, modmap->modifiermap[k], 1, &keysyms_per_keycode_return); log_message (ERROR, "Modifiers List:"); log_message (ERROR, "%d %d %s", i, j, XKeysymToString(keysym[0])); XFree(keysym); */ if (is_grab) XGrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync); else XUngrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window); } k++; } } if (modmap) XFreeModifiermap (modmap); int menu_kc = XKeysymToKeycode(main_window->display, XK_Menu); if (is_grab) XGrabKey(main_window->display, menu_kc, AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync); else XUngrabKey(main_window->display, menu_kc, AnyModifier, window); return; }
void x11_ungrab_key ( Display *display, unsigned int modmask, KeySym key ) { Screen *screen = DefaultScreenOfDisplay ( display ); Window root = RootWindow ( display, XScreenNumberOfScreen ( screen ) ); KeyCode keycode = XKeysymToKeycode ( display, key ); // unbind to combinations of mod and lock masks, so caps and numlock don't confuse people XUngrabKey ( display, keycode, modmask, root ); XUngrabKey ( display, keycode, modmask | LockMask, root ); if ( NumlockMask ) { XUngrabKey ( display, keycode, modmask | NumlockMask, root ); XUngrabKey ( display, keycode, modmask | NumlockMask | LockMask, root ); } }
void AutoTypePlatformX11::unregisterGlobalShortcut(Qt::Key key, Qt::KeyboardModifiers modifiers) { KeyCode keycode = XKeysymToKeycode(m_dpy, charToKeySym(key)); uint nativeModifiers = qtToNativeModifiers(modifiers); XUngrabKey(m_dpy, keycode, nativeModifiers, m_rootWindow); XUngrabKey(m_dpy, keycode, nativeModifiers | Mod2Mask, m_rootWindow); XUngrabKey(m_dpy, keycode, nativeModifiers | LockMask, m_rootWindow); XUngrabKey(m_dpy, keycode, nativeModifiers | Mod2Mask | LockMask, m_rootWindow); m_currentGlobalKey = static_cast<Qt::Key>(0); m_currentGlobalModifiers = 0; m_currentGlobalKeycode = 0; m_currentGlobalNativeModifiers = 0; }
bool KGlobalAccel::ungrabKey( uint keysym, uint mod ) { // Most of this comes from kpanel/main.C // Copyright (C) 1996,97 Matthias Ettrich static int NumLockMask = 0; debug("KGlobalAccel::ungrabKey"); if (!XKeysymToKeycode(qt_xdisplay(), keysym)) return false; if (!NumLockMask){ XModifierKeymap* xmk = XGetModifierMapping(qt_xdisplay()); int i; for (i=0; i<8; i++){ if (xmk->modifiermap[xmk->max_keypermod * i] == XKeysymToKeycode(qt_xdisplay(), XK_Num_Lock)) NumLockMask = (1<<i); } } grabFailed = false; // We wan't to catch only our own errors XSync(qt_xdisplay(),0); XErrorHandler savedErrorHandler=XSetErrorHandler(XGrabErrorHandler); debug("Will ungrab key and variants with keyboard locks: %d, %d", keysym, mod); XUngrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod, qt_xrootwin()); XUngrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask, qt_xrootwin()); XUngrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | NumLockMask, qt_xrootwin()); XUngrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask | NumLockMask, qt_xrootwin()); XSync(qt_xdisplay(),0); XSetErrorHandler(savedErrorHandler); if (grabFailed) { // FIXME: ungrab all successfull grabs! //warning("Global grab failed!"); return false; } return true; }
void grab_modifier_keys(Window window, int is_grab) { int i, k = 0; XModifierKeymap *modmap = XGetModifierMapping (main_window->display); if (modmap == NULL) { log_message(ERROR, _("XGetModifierMapping return NULL. Grabbing modifiers key not changed.")); return; } for (i = 0; i < 8; i++) { int j; for (j = 0; j < modmap->max_keypermod; j++) { if (modmap->modifiermap[k]) { /* int keysyms_per_keycode_return; KeySym *keysym = XGetKeyboardMapping(main_window->display, modmap->modifiermap[k], 1, &keysyms_per_keycode_return); log_message (ERROR, "Modifiers List:"); log_message (ERROR, "%d %d %s", i, j, XKeysymToString(keysym[0])); XFree(keysym);*/ if (is_grab) XGrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync); else XUngrabKey(main_window->display, modmap->modifiermap[k], AnyModifier, window); } k++; } } XFreeModifiermap (modmap); int menu_kc = XKeysymToKeycode(main_window->display, XK_Menu); if (is_grab) XGrabKey(main_window->display, menu_kc, AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync); else XUngrabKey(main_window->display, menu_kc, AnyModifier, window); return; }
//-------------------------------------------------------- // ungrabAll //-------------------------------------------------------- bool KeyGrabber::ungrabAll (Window window) { XUngrabKey(_display, AnyKey, AnyModifier, window); return true; }
static void removePassiveKeyGrab (CompScreen *s, CompKeyBinding *key) { unsigned int modifiers, mask; int i; modifiers = key->modifiers & ~(CompPressMask | CompReleaseMask); if (modifiers == key->modifiers) return; for (i = 0; i < s->nKeyGrab; i++) { if (key->keycode == s->keyGrab[i].keycode && modifiers == s->keyGrab[i].modifiers) { s->keyGrab[i].count--; if (s->keyGrab[i].count) return; s->nKeyGrab--; s->keyGrab = realloc (s->keyGrab, sizeof (CompKeyGrab) * s->nKeyGrab); mask = virtualToRealModMask (s->display, modifiers); if (!(mask & CompNoMask)) { XUngrabKey (s->display->display, key->keycode, mask, s->root); } } } }
static void grab_ungrab_with_ignorable_modifiers (GdkWindow *rootwin, Binding *binding, gboolean grab) { guint mod_masks [] = { 0, /* modifier only */ num_lock_mask, caps_lock_mask, scroll_lock_mask, num_lock_mask | caps_lock_mask, num_lock_mask | scroll_lock_mask, caps_lock_mask | scroll_lock_mask, num_lock_mask | caps_lock_mask | scroll_lock_mask, }; guint i; for (i = 0; i < G_N_ELEMENTS (mod_masks); i++) { if (grab) { XGrabKey (GDK_WINDOW_XDISPLAY (rootwin), binding->keycode, binding->modifiers | mod_masks [i], GDK_WINDOW_XID (rootwin), False, GrabModeAsync, GrabModeAsync); } else { XUngrabKey (GDK_WINDOW_XDISPLAY (rootwin), binding->keycode, binding->modifiers | mod_masks [i], GDK_WINDOW_XID (rootwin)); } } }
void GrabKeyRelease(unsigned int keycode, unsigned int modifiers, Win win) { int i; #if USE_XI2 XIGrabModifiers modifiers_inouts[8]; int num_modifiers; if (modifiers == AnyModifier) { num_modifiers = 1; modifiers_inouts[0].modifiers = XIAnyModifier; modifiers_inouts[0].status = 0; } else { num_modifiers = 0; for (i = 0; i < 8; i++) { if (i && !Mode.masks.mod_combos[i]) continue; modifiers_inouts[num_modifiers].modifiers = modifiers | Mode.masks.mod_combos[i]; modifiers_inouts[num_modifiers].status = 0; num_modifiers++; } } XIUngrabKeycode(disp, DEV_KBD, keycode, WinGetXwin(win), num_modifiers, modifiers_inouts); #else if (modifiers == AnyModifier) { XUngrabKey(disp, keycode, modifiers, WinGetXwin(win)); return; } for (i = 0; i < 8; i++) { if (i && !Mode.masks.mod_combos[i]) continue; XUngrabKey(disp, keycode, modifiers | Mode.masks.mod_combos[i], WinGetXwin(win)); } #endif }
/* ungrab all keys */ static void ungrab_keys() { int i, j; for (i = 0; i < keycount; i++) { for (j = 0; j < (sizeof(mods_to_grab)/sizeof(unsigned int)); j++) XUngrabKey(dpy, keys[i].key, mods_to_grab[j], root); } }
void grab_keys(int mk, int uk, int dk, int mm, int um, int dm, int step) { Display* disp = GDK_DISPLAY(); // ungrab any previous keys XUngrabKey(disp, AnyKey, AnyModifier, GDK_ROOT_WINDOW()); volMuteKey = mk; volUpKey = uk; volDownKey = dk; volMuteMods = mm; volUpMods = um; volDownMods = dm; volStep = step; if (mk < 0 && uk < 0 && dk < 0) return; xErr = 0; errBuf = g_malloc(errBufSize*sizeof(gchar)); printBuf = errBuf + snprintf(errBuf,errBufSize,_("Could not bind the following hotkeys:\n")); errBufSize -= (printBuf - errBuf); if (muteSymStr) g_free(muteSymStr); if (upSymStr) g_free(upSymStr); if (downSymStr) g_free(downSymStr); muteSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(), volMuteKey, 0, 0),volMuteMods); upSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(),volUpKey,0, 0),volUpMods); downSymStr = gtk_accelerator_name(XkbKeycodeToKeysym(GDK_DISPLAY(), volDownKey, 0, 0),volDownMods); XErrorHandler old_hdlr = XSetErrorHandler(errhdl); if (volMuteKey > 0) { muteSerial = NextRequest(disp); XGrabKey(disp,volMuteKey,volMuteMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync); } if (volUpKey > 0) { upSerial = NextRequest(disp); XGrabKey(disp,volUpKey,volUpMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync); } if (volDownKey > 0) { downSerial = NextRequest(disp); XGrabKey(disp,volDownKey,volDownMods,GDK_ROOT_WINDOW(),1,GrabModeAsync,GrabModeAsync); } XFlush(disp); XSync(disp, False); (void) XSetErrorHandler(old_hdlr); if (xErr) g_idle_add(idle_report_error, NULL); else g_free(errBuf); }
static void grab_key_real (Key *key, GdkWindow *root, gboolean grab, int result) { if (grab) XGrabKey (GDK_DISPLAY(), key->keycode, (result | key->state), GDK_WINDOW_XID (root), True, GrabModeAsync, GrabModeAsync); else XUngrabKey(GDK_DISPLAY(), key->keycode, (result | key->state), GDK_WINDOW_XID (root)); }
void X11Util::unregisterHotkey(int keycode) { Display* display = QX11Info::display(); Window root = DefaultRootWindow(display); int modifiers = ControlMask | Mod1Mask; int key = XKeysymToKeycode(display, keycode); XUngrabKey(display, key, modifiers, root); //printf("unregister Hotkey\n"); }
static void spi_dec_x11_ungrab_key (SpiDEController *controller, guint key_val, Accessibility_ControllerEventMask mod_mask) { XUngrabKey (spi_get_display (), key_val, mod_mask, spi_get_root_window ()); }
void GrabKeyRelease(unsigned int key, unsigned int modifiers, Win win) { int i; if (modifiers == AnyModifier) { XUngrabKey(disp, key, modifiers, WinGetXwin(win)); return; } for (i = 0; i < 8; i++) { if (i && !Mode.masks.mod_combos[i]) continue; XUngrabKey(disp, key, modifiers | Mode.masks.mod_combos[i], WinGetXwin(win)); } }
void x11_hotkeys::ungrabkeys() { if (grab_key.key.sym==0) return; Display *d=display; for (int screen = 0; screen<ScreenCount(d); screen++) { XUngrabKey(d, AnyKey, AnyModifier, RootWindow (d, screen)); XUngrabButton(d, AnyButton, AnyModifier, RootWindow (d, screen)); } }
void HotkeyListener::DisableHotkey() { if(m_keycode == 0) return; QAbstractEventDispatcher::instance()->setEventFilter(NULL); unsigned int masks[] = {0, LockMask, Mod2Mask, LockMask | Mod2Mask}; for(unsigned int i = 0; i < sizeof(masks) / sizeof(masks[0]); ++i) { unsigned int m = masks[i] | m_modifiers; XUngrabKey(QX11Info::display(), m_keycode, m, QX11Info::appRootWindow()); } m_keycode = 0; }
static void ungrab_key(KeyCode code) { int i; gdk_error_trap_push(); for (i = 0; i < ScreenCount(GDK_DISPLAY()); i++) XUngrabKey(GDK_DISPLAY(), code, AnyModifier, RootWindow(GDK_DISPLAY(),i)); gdk_flush(); if (gdk_error_trap_pop()) g_warning("Couldn't ungrab keycode %d", code); }
static void cleanup(void) { size_t i; XUngrabKey(dpy, AnyKey, AnyModifier, root); for (i = 0; i < SchemeLast; i++) free(scheme[i]); drw_free(drw); XSync(dpy, False); XCloseDisplay(dpy); }
void grab_key(Window window, KeyCode kc, int is_grab) { int status; if (is_grab) status = XGrabKey(main_window->display, kc, AnyModifier, window, TRUE, GrabModeAsync, GrabModeAsync); else status = XUngrabKey(main_window->display, kc, AnyModifier, window); if (status == BadValue) log_message(ERROR, _("Failed to %s keyboard with error BadValue"), grab_ungrab[is_grab]); else if (status == BadWindow) log_message(ERROR, _("Failed to %s keyboard with error BadWindow"), grab_ungrab[is_grab]); }
void cleanup(void) { XUngrabKey(dpy, AnyKey, AnyModifier, root); drw_clr_free(scheme[SchemeNorm].bg); drw_clr_free(scheme[SchemeNorm].fg); drw_clr_free(scheme[SchemeSel].fg); drw_clr_free(scheme[SchemeSel].bg); drw_clr_free(scheme[SchemeOut].fg); drw_clr_free(scheme[SchemeOut].bg); drw_free(drw); XSync(dpy, False); XCloseDisplay(dpy); }
static void UngrabKeyOrButton ( Widget widget, int keyOrButton, Modifiers modifiers, Boolean isKeyboard) { XtServerGrabRec tempGrab; XtPerWidgetInput pwi; XtCheckSubclass(widget, coreWidgetClass, "in XtUngrabKey or XtUngrabButton"); /* Build a temporary grab list entry */ tempGrab.widget = widget; tempGrab.modifiers = modifiers; tempGrab.keybut = keyOrButton; tempGrab.hasExt = False; LOCK_PROCESS; pwi = _XtGetPerWidgetInput(widget, FALSE); UNLOCK_PROCESS; /* * if there is no entry in the context manager then somethings wrong */ if (!pwi) { XtAppWarningMsg(XtWidgetToApplicationContext(widget), "invalidGrab", "ungrabKeyOrButton", XtCXtToolkitError, "Attempt to remove nonexistent passive grab", (String *)NULL, (Cardinal *)NULL); return; } if (XtIsRealized(widget)) { if (isKeyboard) XUngrabKey(widget->core.screen->display, keyOrButton, (unsigned int)modifiers, widget->core.window); else XUngrabButton(widget->core.screen->display, keyOrButton, (unsigned int)modifiers, widget->core.window); } /* Delete all entries which are encompassed by the specified grab. */ DeleteServerGrabFromList(isKeyboard ? &pwi->keyList : &pwi->ptrList, &tempGrab); }
void grab_spec_keys(Window window, int is_grab) { if (is_grab) { // Ungrab hotkeys in root window XUngrabKey(main_window->display, AnyKey, AnyModifier, DefaultRootWindow (main_window->display)); // Grab all keys... XGrabKey(main_window->display, AnyKey, AnyModifier, window, FALSE, GrabModeAsync, GrabModeAsync); // ...without ModKeys. grab_modifier_keys(window, FALSE); } else { // Ungrab all keys in app window... XUngrabKey(main_window->display, AnyKey, AnyModifier, window); // ... and with hotkeys XUngrabKey(main_window->display, AnyKey, AnyModifier, DefaultRootWindow (main_window->display)); grab_manual_action(); grab_user_action(); // ...without ModKeys. grab_modifier_keys(DefaultRootWindow (main_window->display), FALSE); } }
void ungrabkeys(){ uk_log("Ungrabbing keys"); Window root = DefaultRootWindow(dpy); for(int i=0;i<sizeof(keybindings)/sizeof(event_t);i++){ int mod=0; for(int j=0;j<8;j++){ if( mod & keybindings[i].modifiers || mod == 0 ){ XUngrabKey(dpy,keybindings[i].keycode,mod,root); } mod=!mod?1:mod*2; } } XFlush(dpy); }
static void cleanup(void) { close(STDIN_FILENO); while(stack) { resize(stack, True); unmanage(stack); } XUngrabKey(dpy, AnyKey, AnyModifier, root); XFreeCursor(dpy, cursor[CurNormal]); XFreeCursor(dpy, cursor[CurResize]); XFreeCursor(dpy, cursor[CurMove]); XSetInputFocus(dpy, PointerRoot, RevertToPointerRoot, CurrentTime); XSync(dpy, False); }