コード例 #1
0
ファイル: key.c プロジェクト: morenko/sven
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);
	}
}
コード例 #2
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);
}
コード例 #3
0
ファイル: key.c プロジェクト: GregBowyer/wmii
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);
	}
}
コード例 #4
0
ファイル: GlobalHot.cpp プロジェクト: iamnilay3/ysid
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;
}
コード例 #5
0
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;
}
コード例 #6
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;
}
コード例 #7
0
ファイル: x11-helper.c プロジェクト: jubalh/rofi
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 );
    }
}
コード例 #8
0
ファイル: AutoTypeXCB.cpp プロジェクト: eternaltyro/keepassx
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;
}
コード例 #9
0
ファイル: kglobalaccel.cpp プロジェクト: kthxbyte/KDE1-Linaro
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;
}
コード例 #10
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;
}
コード例 #11
0
ファイル: KeyGrabber.cpp プロジェクト: debars/home
//--------------------------------------------------------
// ungrabAll 
//--------------------------------------------------------
bool KeyGrabber::ungrabAll (Window  window)
{

  XUngrabKey(_display, AnyKey, AnyModifier, window);
 
  return true;
}
コード例 #12
0
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);
	    }
	}
    }
}
コード例 #13
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));
		}
	}
}
コード例 #14
0
ファイル: grabs.c プロジェクト: burzumishi/e16
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
}
コード例 #15
0
ファイル: iocane.c プロジェクト: Gaboose/Iocane
/* 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);
	}
}
コード例 #16
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);
}
コード例 #17
0
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));
}
コード例 #18
0
ファイル: X11Util.cpp プロジェクト: chagge/AlphaDict
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");
}
コード例 #19
0
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 ());
}
コード例 #20
0
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));
     }
}
コード例 #21
0
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));
  }  
}
コード例 #22
0
ファイル: HotkeyListener.cpp プロジェクト: AugRob/ssr
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;
}
コード例 #23
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);
}
コード例 #24
0
ファイル: dmenu.c プロジェクト: pierrechevalier83/dmenu
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);
}
コード例 #25
0
ファイル: utils.c プロジェクト: voidptr/xneur-option
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]);
}
コード例 #26
0
ファイル: dmenu.c プロジェクト: siebenmann/dmenu-cks
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);
}
コード例 #27
0
ファイル: PassivGrab.c プロジェクト: dimkr/tinyxlib
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);
}
コード例 #28
0
ファイル: utils.c プロジェクト: voidptr/xneur-option
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);
    }
}
コード例 #29
0
ファイル: x11.c プロジェクト: richard-jansson/veta
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);
}
コード例 #30
0
ファイル: main.c プロジェクト: csimons/cswm
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);
}