KeySym grab_that_key(char *opt, unsigned int numlockmask) { unsigned int modmask = 0; KeySym keysym; if (strstr(opt, "Control")) modmask = modmask | ControlMask; if (strstr(opt, "Alt")) modmask = modmask | Mod1Mask; if (strstr(opt, "Win")) modmask = modmask | Mod4Mask; if (strstr(opt, "None")) modmask = 0; opt = strrchr(opt, '+'); keysym = XStringToKeysym(++opt); XGrabKey(dpy, XKeysymToKeycode(dpy, keysym), modmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, keysym), LockMask | modmask, root, True, GrabModeAsync, GrabModeAsync); if (numlockmask) { XGrabKey(dpy, XKeysymToKeycode(dpy, keysym), numlockmask | modmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, keysym), numlockmask | LockMask | modmask, root, True, GrabModeAsync, GrabModeAsync); } return keysym; }
bool AutoTypePlatformX11::registerGlobalShortcut(Qt::Key key, Qt::KeyboardModifiers modifiers) { int keycode = XKeysymToKeycode(m_dpy, charToKeySym(key)); uint nativeModifiers = qtToNativeModifiers(modifiers); startCatchXErrors(); XGrabKey(m_dpy, keycode, nativeModifiers, m_rootWindow, true, GrabModeAsync, GrabModeAsync); XGrabKey(m_dpy, keycode, nativeModifiers | Mod2Mask, m_rootWindow, true, GrabModeAsync, GrabModeAsync); XGrabKey(m_dpy, keycode, nativeModifiers | LockMask, m_rootWindow, true, GrabModeAsync, GrabModeAsync); XGrabKey(m_dpy, keycode, nativeModifiers | Mod2Mask | LockMask, m_rootWindow, true, GrabModeAsync, GrabModeAsync); stopCatchXErrors(); if (!m_xErrorOccured) { m_currentGlobalKey = key; m_currentGlobalModifiers = modifiers; m_currentGlobalKeycode = keycode; m_currentGlobalNativeModifiers = nativeModifiers; return true; } else { unregisterGlobalShortcut(key, modifiers); return false; } }
int XttHotkey::grab_key( int keysym, int modifier) { GdkDisplay *display = gdk_display_get_default(); int n_screens = gdk_display_get_n_screens( display); Display *dp = gdk_x11_display_get_xdisplay( display); int mode = GrabModeAsync; int keycode = XKeysymToKeycode( dp, keysym); if ( !keycode) return 0; gdk_error_trap_push(); for ( int i = 0; i < n_screens; i++) { GdkWindow *root = gdk_screen_get_root_window( gdk_display_get_screen( display, i)); Window w = gdk_x11_drawable_get_xid( root); XGrabKey( dp, keycode, modifier, w, True, mode, mode); XGrabKey( dp, keycode, modifier | LockMask, w, True, mode, mode); XGrabKey( dp, keycode, modifier | Mod2Mask, w, True, mode, mode); XGrabKey( dp, keycode, modifier | LockMask | Mod2Mask, w, True, mode, mode); } gdk_flush(); gdk_error_trap_pop(); return 1; }
static void grabkey(struct WM_t *W, struct wmclient *C, KeySym sym, unsigned int mods) { KeyCode code = XKeysymToKeycode(W->XDisplay, sym); XGrabKey(W->XDisplay, code, mods, C->win, 0, GrabModeAsync, GrabModeAsync); XGrabKey(W->XDisplay, code, mods | LockMask, C->win, 0, GrabModeAsync, GrabModeAsync); }
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); }
int main(int argc, const char **argv) { if (!(dpy=XOpenDisplay(0x0))) return 1; scr = DefaultScreen(dpy); root = RootWindow(dpy,scr); sw = DisplayWidth(dpy,scr); sh = DisplayHeight(dpy,scr); if (argc > 1) { if (argv[1][0] == '-' && argv[1][1] == 'h') printf("IOCANE: Copyright 2012, Jesse McClure\nSee `man iocane` for commands and examples.\n"); if (argv[1][0] == '-' && argv[1][1] == '\0') stdinmode(argc,argv); else scriptmode(argc,argv); XCloseDisplay(dpy); return 0; } /* no args -> interactive mode: */ Key *keys = NULL; char *line = (char *) calloc(MAXLINE+MAXSYMLEN+2,sizeof(char)); char keystring[MAXSYMLEN]; KeySym keysym; chdir(getenv("HOME")); FILE *rcfile = fopen(".iocanerc","r"); if (rcfile == NULL) fopen("/usr/share/iocane/iocanerc","r"); if (rcfile == NULL) { fprintf(stderr,"IOCANE: no iocanerc file found.\n"); XCloseDisplay(dpy); return 0; } int i = 0; while (fgets(line,MAXLINE+MAXSYMLEN+2,rcfile) != NULL) { if (line[0] == '#' || line[0] == '\n') continue; strncpy(keystring,line,MAXSYMLEN); *strchr(keystring,' ') = '\0'; if ( (keysym=XStringToKeysym(keystring)) == NoSymbol ) continue; keys = realloc(keys,(i+1) * sizeof(Key)); keys[i].key = XKeysymToKeycode(dpy,keysym); keys[i].command = (char *) calloc(strlen(line) - strlen(keystring),sizeof(char)); strcpy(keys[i].command,strchr(line,' ')+1); XGrabKey(dpy,keys[i].key,0,root,True,GrabModeAsync,GrabModeAsync); XGrabKey(dpy,keys[i++].key,LockMask,root,True,GrabModeAsync,GrabModeAsync); } int keycount = i; free(line); fclose(rcfile); XEvent ev; XKeyEvent *e; while (running && !XNextEvent(dpy,&ev)) if (ev.type == KeyPress) { e = &ev.xkey; for (i = 0; i < keycount; i++) if (e->keycode == keys[i].key && keys[i].command) command(keys[i].command); } for (i = 0; i < keycount; i++) free(keys[i].command); free(keys); XCloseDisplay(dpy); return 0; }
int init_grabber(void) { set_numlockmask(); GdkWindow *gdk_root = gdk_get_default_root_window(); Window x_root = DefaultRootWindow(main_dpy); int i; int error; gdk_window_add_filter(gdk_root, keyevent_filter, NULL); for (i = 0 ; keybinds[i].handler != NULL ; i++) { if (0 != keybinds[i].keycode) { /* now that we have a display, replace KeySym by KeyCode in conf struct */ keybinds[i].keycode = XKeysymToKeycode(main_dpy, keybinds[i].keycode); gdk_error_trap_push(); XGrabKey(main_dpy, keybinds[i].keycode, keybinds[i].mask, x_root, TRUE, GrabModeAsync, GrabModeAsync); if (0 != numlockmask) { XGrabKey(main_dpy, keybinds[i].keycode, numlockmask | keybinds[i].mask, x_root, TRUE, GrabModeAsync, GrabModeAsync); } gdk_flush (); if ((error = gdk_error_trap_pop()) != 0) { if (BadAccess == error) { fprintf(stderr, "[bonnye] Command %s : shortcut already grabbed\n", keybinds[i].name); } else { fprintf(stderr, "[bonnye] Command %s : unknown error %d\n", keybinds[i].name, error); } /* } else { */ /* printf("[bonnye] Grabbing (%d, 0x%x) for %s\n", */ /* keybinds[i].keycode, */ /* keybinds[i].mask, */ /* keybinds[i].name); */ } } } return 0; }
void GrabKeySet(unsigned int keycode, unsigned int modifiers, Win win) { Bool owner_events = False; int pointer_mode = GrabModeAsync; int keyboard_mode = GrabModeSync; int i; #if USE_XI2 EXIEventMask em; XIGrabModifiers modifiers_inouts[8]; int num_modifiers; EXIMaskSetup(&em, DEV_KBD, KeyPressMask | KeyReleaseMask); 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++; } } XIGrabKeycode(disp, DEV_KBD, keycode, WinGetXwin(win), keyboard_mode, pointer_mode, owner_events, &em.em, num_modifiers, modifiers_inouts); #else if (modifiers == AnyModifier) { XGrabKey(disp, keycode, modifiers, WinGetXwin(win), owner_events, pointer_mode, keyboard_mode); return; } for (i = 0; i < 8; i++) { if (i && !Mode.masks.mod_combos[i]) continue; XGrabKey(disp, keycode, modifiers | Mode.masks.mod_combos[i], WinGetXwin(win), owner_events, pointer_mode, keyboard_mode); } #endif }
bool KGlobalAccel::grabKey( uint keysym, uint mod ) { // Most of this comes from kpanel/main.C // Copyright (C) 1996,97 Matthias Ettrich static int NumLockMask = 0; debug("KGlobalAccel::grabKey"); 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 grab key and variants with keyboard locks: %d, %d", keysym, mod); XGrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod, qt_xrootwin(), True, GrabModeAsync, GrabModeSync); XGrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask, qt_xrootwin(), True, GrabModeAsync, GrabModeSync); XGrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | NumLockMask, qt_xrootwin(), True, GrabModeAsync, GrabModeSync); XGrabKey(qt_xdisplay(), XKeysymToKeycode(qt_xdisplay(), keysym), mod | LockMask | NumLockMask, qt_xrootwin(), True, GrabModeAsync, GrabModeSync); XSync(qt_xdisplay(),0); XSetErrorHandler(savedErrorHandler); debug(" grabbed"); 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); 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; }
//-------------------------------------------------------- // grab //-------------------------------------------------------- bool KeyGrabber::grab (const KeyCode & keyCode, const unsigned int & modifierMask, Window window) { int ret = XGrabKey(_display, keyCode, modifierMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|LockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|_scrolllockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|_numlockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|LockMask|_scrolllockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|_scrolllockMask|_numlockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|_numlockMask|LockMask, window, True, GrabModeAsync, GrabModeAsync); XGrabKey(_display, keyCode, modifierMask|_numlockMask|LockMask|_scrolllockMask, window, True, GrabModeAsync, GrabModeAsync); // Um. Isn't there SOME way we can tell if a grab worked??? // return (ret == Success); return true; }
bool GlobalHotImpl::register_hot(quint32 native_key, quint32 native_mods) { Display* display = QX11Info::display(); Window window = QX11Info::appRootWindow(); Bool owner = True; int pointer = GrabModeAsync; int keyboard = GrabModeAsync; hot_error = false; orig_x_err_handler = XSetErrorHandler(hot_x_err_handler); XGrabKey(display, native_key, native_mods, window, owner, pointer, keyboard); XGrabKey(display, native_key, native_mods | Mod2Mask, window, owner, pointer, keyboard); // allow numlock XSync(display, False); XSetErrorHandler(orig_x_err_handler); return !hot_error; }
/** * Actually grab a key (and its *Lock combinations). */ void grabKey(Display* display, Window rootWindow, int keycode, int modifier) { XGrabKey(display, keycode, modifier, rootWindow, False, GrabModeAsync, GrabModeAsync); if (modifier != AnyModifier) { // Also grab with NumLock, CapsLock, ScrollLock if (numLockMask) { XGrabKey(display, keycode, modifier | numLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (capsLockMask) { XGrabKey(display, keycode, modifier | capsLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (scrollLockMask) { XGrabKey(display, keycode, modifier | scrollLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (numLockMask && capsLockMask) { XGrabKey(display, keycode, modifier | numLockMask | capsLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (numLockMask && scrollLockMask) { XGrabKey(display, keycode, modifier | numLockMask | scrollLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (capsLockMask && scrollLockMask) { XGrabKey(display, keycode, modifier | capsLockMask | scrollLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } if (numLockMask && capsLockMask && scrollLockMask) { XGrabKey(display, keycode, modifier | numLockMask | capsLockMask | scrollLockMask, rootWindow, False, GrabModeAsync, GrabModeAsync); } } }
void SystemKeys::addKey(int keycode, unsigned int mask) { //Find the X11 KeyCode we are listening for. //KeyCode key = XKeysymToKeycode(QX11Info::display(), XK_p); //unsigned int mask = Mod1Mask; KeyCode key = keycode; //ShiftMask XGrabKey(QX11Info::display(), key, mask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //NumberLockMask XGrabKey(QX11Info::display(), key, mask | NumberLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //ScrollLockMask XGrabKey(QX11Info::display(), key, mask | ScrollLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //CapsLockMask XGrabKey(QX11Info::display(), key, mask | CapsLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //NumberLockMask | ScrollLockMask XGrabKey(QX11Info::display(), key, mask | NumberLockMask | ScrollLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //NumberLockMask | CapsLockMask XGrabKey(QX11Info::display(), key, mask | NumberLockMask | CapsLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //ScrollLockMask | CapsLockMask XGrabKey(QX11Info::display(), key, mask | ScrollLockMask | CapsLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); //NumberLockMask | ScrollLockMask | CapsLockMask XGrabKey(QX11Info::display(), key, mask | NumberLockMask | ScrollLockMask | CapsLockMask, QX11Info::appRootWindow(QX11Info::appScreen()), false, GrabModeAsync, GrabModeAsync); }
void grabkey(unsigned int modmask, KeySym key) { XGrabKey(dpy, XKeysymToKeycode(dpy, key), modmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, key), LockMask | modmask, root, True, GrabModeAsync, GrabModeAsync); if(numlockmask) { XGrabKey(dpy, XKeysymToKeycode(dpy, key), modmask | numlockmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, key), LockMask | modmask | numlockmask, root, True, GrabModeAsync, GrabModeAsync); } };
void grab_key(void) { XGrabKey(dpy, XKeysymToKeycode(dpy, opt_key), modmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, opt_key), LockMask|modmask, root, True, GrabModeAsync, GrabModeAsync); if(numlockmask) { XGrabKey(dpy, XKeysymToKeycode(dpy, opt_key), numlockmask|modmask, root, True, GrabModeAsync, GrabModeAsync); XGrabKey(dpy, XKeysymToKeycode(dpy, opt_key), numlockmask|LockMask |modmask, root, True, GrabModeAsync, GrabModeAsync); } }
bool QxtGlobalShortcutPrivate::registerShortcut(quint32 nativeKey, quint32 nativeMods) { Display* display = QX11Info::display(); Window window = QX11Info::appRootWindow(); Bool owner = True; int pointer = GrabModeAsync; int keyboard = GrabModeAsync; error = false; original_x_errhandler = XSetErrorHandler(qxt_x_errhandler); XGrabKey(display, nativeKey, nativeMods, window, owner, pointer, keyboard); XGrabKey(display, nativeKey, nativeMods | Mod2Mask, window, owner, pointer, keyboard); // allow numlock XSync(display, False); XSetErrorHandler(original_x_errhandler); return !error; }
// bind a key combination on a root window, compensating for Lock* states void x11_grab_key ( Display *display, unsigned int modmask, KeySym key ) { Screen *screen = DefaultScreenOfDisplay ( display ); Window root = RootWindow ( display, XScreenNumberOfScreen ( screen ) ); KeyCode keycode = XKeysymToKeycode ( display, key ); // bind to combinations of mod and lock masks, so caps and numlock don't confuse people XGrabKey ( display, keycode, modmask, root, True, GrabModeAsync, GrabModeAsync ); XGrabKey ( display, keycode, modmask | LockMask, root, True, GrabModeAsync, GrabModeAsync ); if ( NumlockMask ) { XGrabKey ( display, keycode, modmask | NumlockMask, root, True, GrabModeAsync, GrabModeAsync ); XGrabKey ( display, keycode, modmask | NumlockMask | LockMask, root, True, GrabModeAsync, GrabModeAsync ); } }
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; }
GlobalKey::GlobalKey(CommandDef *cmd) { m_key = Q3Accel::stringToKey(cmd->accel); m_state = 0; if (m_key & Qt::SHIFT){ m_key &= ~Qt::SHIFT; m_state |= 1; } if (m_key & Qt::CTRL){ m_key &= ~Qt::CTRL; m_state |= 4; } if (m_key & Qt::ALT){ m_key &= ~Qt::ALT; m_state |= 8; } m_key &= ~Qt::UNICODE_ACCEL; for (const TransKey *t = g_rgQtToSymX; t->x_key; t++){ if (t->qt_key == m_key){ m_key = t->x_key; break; } } m_key = XKeysymToKeycode( QX11Info::display(), m_key); XSync( QX11Info::display(), 0 ); XErrorHandler savedErrorHandler = XSetErrorHandler(XGrabErrorHandler); XGrabKey( QX11Info::display(), m_key, m_state, QX11Info::appRootWindow(QX11Info::appScreen()), True, GrabModeAsync, GrabModeSync); XSync( QX11Info::display(), 0 ); XSetErrorHandler( savedErrorHandler ); }
static void add_hot_key(const char* keyname, const char* command) { char* copy = strdup(keyname); char* unmodified = strrchr(copy, '-'); unsigned int modifiers = 0; if (unmodified == NULL) { unmodified = copy; } else { *unmodified = 0; ++ unmodified; modifiers = parse_modifiers(copy, keyname); } HotKey* new_key = new HotKey; new_key->keysym = XStringToKeysym(unmodified); new_key->modifiers = modifiers; new_key->command = strdup(command); new_key->next = hotkeys; hotkeys = new_key; XSynchronize(dpy, True); attempting_to_grab = keyname; XSetErrorHandler(report_key_grab_error); for (int screen = 0; screen < screen_count; ++screen) { Window root = RootWindow(dpy, screen); XGrabKey(dpy, XKeysymToKeycode(dpy, new_key->keysym), modifiers, root, False, GrabModeAsync, GrabModeAsync); } XSetErrorHandler(NULL); free(copy); }
/* Grab the key while ignoring annoying modifier keys including caps lock, num lock, and scroll lock. */ void grab_key (KeySym keysym, unsigned int modifiers, Window grab_window) { unsigned int mod_list[8]; int i; KeyCode keycode; unsigned int mod; /* Convert to a modifier mask that X Windows will understand. */ modifiers = rp_mask_to_x11_mask (modifiers); if (!keysym_to_keycode_mod (keysym, &keycode, &mod)) return; PRINT_DEBUG (("keycode_mod: %ld %d %d\n", keysym, keycode, mod)); modifiers |= mod; /* Create a list of all possible combinations of ignored modifiers. Assumes there are only 3 ignored modifiers. */ mod_list[0] = 0; mod_list[1] = LockMask; mod_list[2] = rp_modifier_info.num_lock_mask; mod_list[3] = mod_list[1] | mod_list[2]; mod_list[4] = rp_modifier_info.scroll_lock_mask; mod_list[5] = mod_list[1] | mod_list[4]; mod_list[6] = mod_list[2] | mod_list[4]; mod_list[7] = mod_list[1] | mod_list[2] | mod_list[4]; /* Grab every combination of ignored modifiers. */ for (i=0; i<8; i++) { XGrabKey(dpy, keycode, modifiers | mod_list[i], grab_window, True, GrabModeAsync, GrabModeAsync); } }
void grab_keys ( KTKeySettingsList *key_list, Display *display ) /* Input: key_list - The list of keys to grab display - Specifies the connection to the X server Output: - Returns: - Desciption: This function establishes a passive grab on the keyboard for every key in key_list. For each key in key_list auto repeat mode is turned on for those keys with auto_repeat_on member equal to TRUE. */ { KTKeySettings *key; XKeyboardControl keyboard_control; /* Set our own error handler so that the program continues after grabbing * a key failed. */ XSetErrorHandler ((XErrorHandler) x_error_handler); for (key = key_list->head; key != NULL; key = key->next) { XGrabKey (display, key->keycode, AnyModifier, DefaultRootWindow(display), False, GrabModeAsync, GrabModeAsync); keyboard_control.key = key->keycode; keyboard_control.auto_repeat_mode = key->auto_repeat_on ? AutoRepeatModeOn : AutoRepeatModeOff; /* Turn for the current key auto repeat on/off */ XChangeKeyboardControl (display, KBKey|KBAutoRepeatMode, &keyboard_control); } }
/* grab all keys * For every valid keycode found in a config file, the associated key on * the keyboard is grabbed. */ static void grab_keys() { int i,j; /* iterate over all elements in `keys' */ for (i = 0; i < keycount; i++) { for (j = 0; j < (sizeof(mods_to_grab)/sizeof(unsigned int)); j++) XGrabKey(dpy, keys[i].key, mods_to_grab[j], root,True,GrabModeAsync, GrabModeAsync); } /* if defined and not already grabbed, grab the special key to grab/ungrab * all keys */ if ((grab_ungrab_key != NO_TOGGLE_KEY) && (grab_ungrab_key_grabbed == False)) { for (j = 0; j < (sizeof(mods_to_grab)/sizeof(unsigned int)); j++) XGrabKey(dpy, grab_ungrab_key, mods_to_grab[j], root,True,GrabModeAsync, GrabModeAsync); grab_ungrab_key_grabbed = True; } }
gboolean xfwm_device_grab_keycode (XfwmDevices *devices, Display *display, gint keycode, guint modifiers, Window grab_window, gboolean owner_events, guint event_mask, gint grab_mode, gint paired_device_mode) { gboolean result; Status status; #ifdef HAVE_XI2 XIGrabModifiers xi2_modifiers; XIEventMask xievent_mask; #endif #ifdef HAVE_XI2 if (devices->xi2_available) { xi2_modifiers.modifiers = xi2_modifier_mask (modifiers); xi2_modifiers.status = 0; xfwm_device_fill_xi2_event_mask (&xievent_mask, event_mask); status = XIGrabKeycode (display, devices->keyboard.xi2_device, keycode, grab_window, grab_mode, paired_device_mode, owner_events, &xievent_mask, 1, &xi2_modifiers); g_free (xievent_mask.mask); result = (status == XIGrabSuccess); } else #endif { status = XGrabKey (display, keycode, modifiers, grab_window, owner_events, grab_mode, paired_device_mode); result = (status == GrabSuccess); } return result; }
static KeyCode grab_key(char *keystring) { KeySym sym; KeyCode code; gint i; if ((sym = XStringToKeysym(keystring)) == NoSymbol) return 0; if ((code = XKeysymToKeycode(GDK_DISPLAY(), sym)) == 0) return 0; gdk_error_trap_push(); for (i = 0; i < ScreenCount(GDK_DISPLAY()); i++) { XGrabKey(GDK_DISPLAY(), code, AnyModifier, RootWindow(GDK_DISPLAY(),i), 1, GrabModeAsync, GrabModeAsync); } gdk_flush(); if (gdk_error_trap_pop()) { g_warning("Couldn't grab %s: another client may already have done so", keystring); return 0; } return code; }
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 grab_manual_action(void) { for (enum _hotkey_action action = 0; action < MAX_HOTKEYS; action++) { if (btable[action].key_sym == 0) continue; XGrabKey(main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->numlock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->capslock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->capslock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, btable[action].key_sym), btable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); } }
void grab_user_action(void) { for (int action = 0; action < xconfig->actions_count; action++) { if (ubtable[action].key_sym == 0) continue; XGrabKey(main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->numlock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->capslock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->capslock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); if (main_window->keymap->numlock_mask && main_window->keymap->capslock_mask && main_window->keymap->scrolllock_mask) XGrabKey (main_window->display, XKeysymToKeycode(main_window->display, ubtable[action].key_sym), ubtable[action].modifier_mask | main_window->keymap->numlock_mask | main_window->keymap->capslock_mask | main_window->keymap->scrolllock_mask, DefaultRootWindow (main_window->display), FALSE, GrabModeAsync, GrabModeAsync); } }
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); }