コード例 #1
0
ファイル: yeahconsole.c プロジェクト: jceb/yeahconsole
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;
}
コード例 #2
0
ファイル: AutoTypeXCB.cpp プロジェクト: eternaltyro/keepassx
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;
    }
}
コード例 #3
0
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;
}
コード例 #4
0
ファイル: client.c プロジェクト: chrisdiamand/wm
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);
}
コード例 #5
0
ファイル: hotkeys.c プロジェクト: Cw1X/pnmixer
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);
}
コード例 #6
0
ファイル: iocane.c プロジェクト: gk7/Iocane
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;
}
コード例 #7
0
ファイル: grabber.c プロジェクト: jpinon/bonnye
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;
}
コード例 #8
0
ファイル: grabs.c プロジェクト: burzumishi/e16
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
}
コード例 #9
0
ファイル: kglobalaccel.cpp プロジェクト: kthxbyte/KDE1-Linaro
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;
}
コード例 #10
0
ファイル: utils.c プロジェクト: voidptr/xneur-option
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;
}
コード例 #11
0
ファイル: KeyGrabber.cpp プロジェクト: debars/home
//--------------------------------------------------------
// 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;
}
コード例 #12
0
ファイル: GlobalHot.cpp プロジェクト: iamnilay3/ysid
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;
}
コード例 #13
0
ファイル: xkeys.c プロジェクト: mgropp/mplayer-transcribe
/**
 * 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);
		}
	}
}
コード例 #14
0
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);
}
コード例 #15
0
ファイル: mmkeyosd.c プロジェクト: dapus/mmkeyosd
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);
	}
};
コード例 #16
0
ファイル: shortcut.c プロジェクト: matejekm/ftjerm
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);
    }
}
コード例 #17
0
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;
}
コード例 #18
0
ファイル: x11-helper.c プロジェクト: jubalh/rofi
// 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 );
    }
}
コード例 #19
0
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;
}
コード例 #20
0
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 );
}
コード例 #21
0
ファイル: speckeysd.cpp プロジェクト: 007durgesh219/jessies
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);
}
コード例 #22
0
ファイル: input.c プロジェクト: ivoarch/ratpoison
/* 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);
    }
}
コード例 #23
0
ファイル: grab_keys.c プロジェクト: paulmadore/G-Keymap
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);
	}
}
コード例 #24
0
ファイル: iocane.c プロジェクト: Gaboose/Iocane
/* 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;
	}
}
コード例 #25
0
ファイル: device.c プロジェクト: iglosiggio/xfwm4
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;
}
コード例 #26
0
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;
}
コード例 #27
0
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));
		}
	}
}
コード例 #28
0
ファイル: bind_table.c プロジェクト: voidptr/xneur-option
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);
	}
}
コード例 #29
0
ファイル: bind_table.c プロジェクト: voidptr/xneur-option
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);
	}		
}
コード例 #30
0
ファイル: barewm.c プロジェクト: wraith0x2b/barewm
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);
}