static gint spi_dec_x11_get_keycode (SpiDEController *controller, gint keysym, gchar *key_str, gboolean fix, guint *modmask) { KeyCode keycode = 0; if (key_str && key_str[0]) keysym = XStringToKeysym(key_str); keycode = XKeysymToKeycode (spi_get_display (), (KeySym) keysym); if (!keycode && fix) { DEControllerPrivateData *priv = controller->priv; /* if there's no keycode available, fix it */ if (replace_map_keysym (priv, priv->reserved_keycode, keysym)) { keycode = priv->reserved_keycode; /* * queue a timer to restore the old keycode. Ugly, but required * due to races / asynchronous X delivery. * Long-term fix is to extend the X keymap here instead of replace entries. */ priv->reserved_reset_timeout = g_timeout_add (500, spi_dec_reset_reserved, priv); } if (modmask) *modmask = 0; return keycode; } if (modmask) *modmask = keysym_mod_mask (keysym, keycode); return keycode; }
static void xkeymap_char_to_keycode(struct _xkeymap *p, char ch, KeyCode *kc, int *modifier) { if ((ch == 10) || (ch == 13)) { *kc = XKeysymToKeycode(main_window->display, XK_Return); *modifier = 0; return; } for (int i = p->min_keycode+1; i <= p->max_keycode; i++) { if (p->alphabet[p->latin_group][i].lower_sym[0] != NULLSYM) if (p->alphabet[p->latin_group][i].lower_sym[0] == ch) { *kc = i; *modifier = 0; return; } if (p->alphabet[p->latin_group][i].upper_sym[0] != NULLSYM) if (p->alphabet[p->latin_group][i].upper_sym[0] == ch) { *kc = i; *modifier = 1; return; } } kc = 0; modifier = 0; return; }
void handleKeyEvent(Display * dpy, MouseEvent *pEvent) { unsigned int keycode = pEvent->value & 0xff; int keysym; switch (keycode) { case kKeycodeLeft: keysym = XK_Left; break; case kKeycodeRight: keysym = XK_Right; break; case kKeycodeDown: keysym = XK_Down; break; case kKeycodeUp: keysym = XK_Up; break; case kKeycodeBackSpace: keysym = XK_BackSpace; break; case kKeycodeReturn: keysym = XK_Return; break; default: XBell(dpy, 100); return; break; } KeyCode x11Keycode = XKeysymToKeycode(dpy, keysym); if (x11Keycode != 0) { XTestFakeKeyEvent(dpy, x11Keycode, pEvent->type == EVENT_KEY_DOWN, 0); } }
/* * Purpose: * Send a key press to a display * * Parameters: * 1st - filled in video display structure * 2nd - key press to send * 3rd - PRESS or RELEASE * * Returns: * GOOD on success * BAD on failure * * History: * 21/03/2001 (Mike Bennett): Coded to deal with special characters * 22/03/2001 (Mike Bennett): Rewrote to use index arrays for specials * 14/04/2001 (Mike Bennett): Rewrote completely to use external user * definable key maps * * Note: * This can easily be optimised in many ways, and REALLY should * be. Anyone want to volunteer? Join the Down with Nasty Code * Now Organisation :) */ int sendKey(WSETUP *wayv, GDISPLAY *video, char *key, int state) { #ifdef HAVE_X_TEST int i; if(!XQueryExtension(video->display, "XTEST", &i, &i, &i)) return BAD; /* Figure out what kind of keypress to send */ for(i = 0; wayv->keymap[i] != NULL; i++) { /* Send a normal key PRESS/RELEASE? */ if(wayv->keymap[i]->normal && strcmp(wayv->keymap[i]->normal, key) == 0) { XTestFakeKeyEvent(video->display, wayv->keymap[i]->kcode, state, 0); break; } /* Send a key PRESS/RELEASE with shift? */ if(wayv->keymap[i]->shift && strcmp(wayv->keymap[i]->shift, key) == 0) { XTestFakeKeyEvent(video->display, XKeysymToKeycode(video->display, XK_Shift_L), state, 0); XTestFakeKeyEvent(video->display, wayv->keymap[i]->kcode, state, 0); break; } } XFlush(video->display); /* XSync(video->display, True); */ #endif /* HAVE_X_TEST */ return GOOD; }
/* ** Part of dialog mnemonic processing. Search the widget tree under w ** for widgets with mnemonics. When found, add a passive grab to the ** dialog widget for the mnemonic character, thus directing mnemonic ** events to the dialog widget. */ static void addMnemonicGrabs(Widget dialog, Widget w) { char mneString[2]; WidgetList children; int numChildren, i, isMenu; KeySym mnemonic = '\0'; unsigned char rowColType; if (XtIsComposite(w)) { if (XtClass(w) == xmRowColumnWidgetClass) { XtVaGetValues(w, XmNrowColumnType, &rowColType, 0); isMenu = rowColType != XmWORK_AREA; } else isMenu = False; if (!isMenu) { XtVaGetValues(w, XmNchildren, &children, XmNnumChildren, &numChildren, 0); for (i=0; i<numChildren; i++) addMnemonicGrabs(dialog, children[i]); } } else { XtVaGetValues(w, XmNmnemonic, &mnemonic, 0); if (mnemonic != '\0') { mneString[0] = mnemonic; mneString[1] = '\0'; XtGrabKey(dialog, XKeysymToKeycode(XtDisplay(dialog), XStringToKeysym(mneString)), Mod1Mask, True, GrabModeAsync, GrabModeAsync); } } }
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; }
void setup() { unsigned int i, j; XModifierKeymap *modmap; XSetWindowAttributes wa; /* init modifier map */ modmap = XGetModifierMapping(dpy); for(i = 0; i < 8; i++) for(j = 0; j < modmap->max_keypermod; j++) { if(modmap->modifiermap[i * modmap->max_keypermod + j] == XKeysymToKeycode(dpy, XK_Num_Lock)) numlockmask = (1 << i); } XFreeModifiermap(modmap); wa.override_redirect = 0; wa.background_pixmap = ParentRelative; wa.event_mask = ExposureMask | ButtonPressMask | KeyPressMask; mw = DisplayWidth(dpy, screen)-mx; my = bottom ? DisplayHeight(dpy, screen) - mh : 0; mh = 20; win = XCreateWindow(dpy, root, mx, my, mw, mh, 0, DefaultDepth(dpy, screen), CopyFromParent, DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixmap | CWEventMask, &wa); setstruts(0); XMapRaised(dpy, win); XMoveWindow(dpy, win, mx, my); }
bool KeyboardDevice::doKeyAction(Action action, int nativeKey, bool alterPressedKeys) { bool result = true; #ifdef Q_OS_UNIX KeyCode keyCode = XKeysymToKeycode(QX11Info::display(), nativeKey); if(action == Press || action == Trigger) result &= XTestFakeKeyEvent(QX11Info::display(), keyCode, True, CurrentTime); if(action == Release || action == Trigger) result &= XTestFakeKeyEvent(QX11Info::display(), keyCode, False, CurrentTime); XFlush(QX11Info::display()); #endif #ifdef Q_OS_WIN INPUT input; SecureZeroMemory(&input, sizeof(INPUT)); input.type = INPUT_KEYBOARD; switch(mType) { case Win32: { input.ki.wVk = nativeKey; HKL keyboardLayout = GetKeyboardLayout(0); input.ki.wScan = MapVirtualKeyEx(nativeKey, MAPVK_VK_TO_VSC, keyboardLayout); if(extendedKeys.count(nativeKey) > 0) input.ki.dwFlags |= KEYEVENTF_EXTENDEDKEY; } break; case DirectX: input.ki.wVk = 0; input.ki.wScan = ActionTools::KeyMapper::toDirectXKey(nativeKey); break; } if(action == Press || action == Trigger) result &= (SendInput(1, &input, sizeof(INPUT)) != 0); if(action == Release || action == Trigger) { input.ki.dwFlags |= KEYEVENTF_KEYUP; result &= (SendInput(1, &input, sizeof(INPUT)) != 0); } #endif if(alterPressedKeys) { if(action == Press) mPressedKeys.insert(nativeKey); else if(action == Release) mPressedKeys.remove(nativeKey); } return result; }
/* keyboard */ void keyboard_set_state (const char* key, int state) { Display* display = XOpenDisplay(NULL); KeySym sym = XStringToKeysym(key); KeyCode keycode = XKeysymToKeycode(display, sym); XTestFakeKeyEvent(display, keycode, state, 0); XCloseDisplay(display); }
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 GLInjectLauncher::UpdateHotkey(bool enabled, unsigned int keysym, unsigned int modifiers) { GLInjectHeader *header = (GLInjectHeader*) m_shm_main_ptr; std::atomic_thread_fence(std::memory_order_acquire); header->hotkey_enabled = enabled; header->hotkey_keycode = XKeysymToKeycode(QX11Info::display(), keysym); header->hotkey_modifiers = modifiers; std::atomic_thread_fence(std::memory_order_release); }
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); } }
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); }
/* * DoSendString - actually sends a string to the X Window having input focus * * The main task of this function is to convert the ascii char values * into X KeyCodes. But they need to be converted to X KeySyms first * and then to the keycodes. The KeyCodes can have any random values * and are not contiguous like the ascii values are. * * Some escape sequences can be converted to the appropriate KeyCodes * by this function. See the code below for details */ void CKeySendImpl::DoSendString(const StringX& str, unsigned delayMS, bool emulateMods) { atGlobals.error_detected = false; atGlobals.errorString[0] = 0; AutotypeEvent event(m_display); // convert all the chars into keycodes and required shift states first // Abort if any of the characters cannot be converted typedef std::vector<KeyPressInfo> KeyPressInfoVector; KeyPressInfoVector keypresses; for (StringX::const_iterator srcIter = str.begin(); srcIter != str.end(); ++srcIter) { //throw away 'vertical tab' chars which are only used on Windows to send a shift+tab //as a workaround for some issues with IE if (*srcIter == _T('\v')) continue; //Try a regular conversion first KeySym sym = wchar2keysym(*srcIter); if (NoSymbol != sym) { KeyPressInfo keypress = {0, 0}; if ((keypress.code = XKeysymToKeycode(event.display, sym)) != 0) { //non-zero return value implies sym -> code was successful keypress.state |= CalcModifiersForKeysym(keypress.code, sym, event.display); keypresses.push_back(keypress); } else { const char* symStr = XKeysymToString(sym); snprintf(atGlobals.errorString, NumberOf(atGlobals.errorString), "Could not get keycode for key char(%s) - sym(%#X) - str(%s). Aborting autotype.\n\nIf \'xmodmap -pk\' does not list this KeySym, you probably need to install an appropriate keyboard layout.", wchar2bytes(*srcIter).str(), static_cast<int>(sym), symStr ? symStr : "NULL"); atGlobals.error_detected = True; return; } } else { snprintf(atGlobals.errorString, NumberOf(atGlobals.errorString), "Cannot convert '%s' [U+%04X] to keysym. Aborting autotype", wchar2bytes(*srcIter).str(), int(*srcIter)); atGlobals.error_detected = True; return; } } m_method->EmulateMods(emulateMods); for (KeyPressInfoVector::const_iterator itr = keypresses.begin(); itr != keypresses.end() && !atGlobals.error_detected; ++itr) { event.keycode = itr->code; event.state = itr->state; event.time = CurrentTime; (*m_method)(event); pws_os::sleep_ms(delayMS); } }
bool wxUIActionSimulator::DoKey(int keycode, int modifiers, bool isDown) { wxX11Display display; wxCHECK_MSG(display, false, "No display available!"); int mask, type; if ( isDown ) { type = KeyPress; mask = KeyPressMask; } else { type = KeyRelease; mask = KeyReleaseMask; } WXKeySym xkeysym = wxCharCodeWXToX(keycode); KeyCode xkeycode = XKeysymToKeycode(display, xkeysym); if ( xkeycode == NoSymbol ) return false; Window focus; int revert; XGetInputFocus(display, &focus, &revert); if (focus == None) return false; int mod = 0; if (modifiers & wxMOD_SHIFT) mod |= ShiftMask; //Mod1 is alt in the vast majority of cases if (modifiers & wxMOD_ALT) mod |= Mod1Mask; if (modifiers & wxMOD_CMD) mod |= ControlMask; XKeyEvent event; event.display = display; event.window = focus; event.root = DefaultRootWindow(event.display); event.subwindow = None; event.time = CurrentTime; event.x = 1; event.y = 1; event.x_root = 1; event.y_root = 1; event.same_screen = True; event.type = type; event.state = mod; event.keycode = xkeycode; XSendEvent(event.display, event.window, True, mask, (XEvent*) &event); return true; }
bool GetXlibKeyState(int key) { if(CurrentXDisplay == NULL) return false; KeySym ks = 0; if(key >= eRENDERDOC_Key_A && key <= eRENDERDOC_Key_Z) ks = key; if(key >= eRENDERDOC_Key_0 && key <= eRENDERDOC_Key_9) ks = key; switch(key) { case eRENDERDOC_Key_Divide: ks = XK_KP_Divide; break; case eRENDERDOC_Key_Multiply: ks = XK_KP_Multiply; break; case eRENDERDOC_Key_Subtract: ks = XK_KP_Subtract; break; case eRENDERDOC_Key_Plus: ks = XK_KP_Add; break; case eRENDERDOC_Key_F1: ks = XK_F1; break; case eRENDERDOC_Key_F2: ks = XK_F2; break; case eRENDERDOC_Key_F3: ks = XK_F3; break; case eRENDERDOC_Key_F4: ks = XK_F4; break; case eRENDERDOC_Key_F5: ks = XK_F5; break; case eRENDERDOC_Key_F6: ks = XK_F6; break; case eRENDERDOC_Key_F7: ks = XK_F7; break; case eRENDERDOC_Key_F8: ks = XK_F8; break; case eRENDERDOC_Key_F9: ks = XK_F9; break; case eRENDERDOC_Key_F10: ks = XK_F10; break; case eRENDERDOC_Key_F11: ks = XK_F11; break; case eRENDERDOC_Key_F12: ks = XK_F12; break; case eRENDERDOC_Key_Home: ks = XK_Home; break; case eRENDERDOC_Key_End: ks = XK_End; break; case eRENDERDOC_Key_Insert: ks = XK_Insert; break; case eRENDERDOC_Key_Delete: ks = XK_Delete; break; case eRENDERDOC_Key_PageUp: ks = XK_Prior; break; case eRENDERDOC_Key_PageDn: ks = XK_Next; break; case eRENDERDOC_Key_Backspace: ks = XK_BackSpace; break; case eRENDERDOC_Key_Tab: ks = XK_Tab; break; case eRENDERDOC_Key_PrtScrn: ks = XK_Print; break; case eRENDERDOC_Key_Pause: ks = XK_Pause; break; default: break; } if(ks == 0) return false; KeyCode kc = XKeysymToKeycode(CurrentXDisplay, ks); char keyState[32]; XQueryKeymap(CurrentXDisplay, keyState); int byteIdx = (kc / 8); int bitMask = 1 << (kc % 8); uint8_t keyByte = (uint8_t)keyState[byteIdx]; return (keyByte & bitMask) != 0; }
void send_fake_key_eve2(KeySym key, gboolean press) { #if WIN32 win32_FakeKey(key, press); #else KeyCode kc = XKeysymToKeycode(dpy, key); XTestFakeKeyEvent(dpy, kc, press, CurrentTime); #endif }
void send(char c, int delay=0){ bool need_shift=false; KeyCode kc = char2KeyCode(c, need_shift); if(kc==0) return; printf("DEBUG: send kc = %d\n",kc); if(!shift && need_shift){ XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), True, CurrentTime); // is_press } XTestFakeKeyEvent(display, kc, True, 30); // is_press XFlush(display); XTestFakeKeyEvent(display, kc, False, 30); // KeyUp XFlush(display); if(!shift && need_shift){ XTestFakeKeyEvent(display, XKeysymToKeycode(display, XK_Shift_L), False, CurrentTime); // is_press } XFlush(display); if(delay>0) usleep(delay*1000); // unit: ms }
void x_grab_key_init() { x_disp = XOpenDisplay (NULL); x_screen = DefaultScreen (x_disp); x_root = RootWindow (x_disp, x_screen); key_code = XKeysymToKeycode(x_disp , XK_Meta_R); XSelectInput(x_disp , x_root , KeyReleaseMask); XGrabKey(x_disp , key_code , AnyModifier , x_root, 1 , GrabModeAsync,GrabModeAsync ); }
static KeyCode keyToKeycode(const char *key) { KeySym keySym = XStringToKeysym(key); if(keySym == NoSymbol) return keyToKeycode("space"); return XKeysymToKeycode(QX11Info::display(), keySym); }
void CKeySendImpl::SelectAll(unsigned delayMS) { AutotypeEvent event(m_display); event.keycode = XKeysymToKeycode(event.display, XK_a); event.state = ControlMask; event.time = CurrentTime; (*m_method)(event); pws_os::sleep_ms(delayMS); }
void ParseKeyBinding( ConfigItem *item, FreeStorageElem *func_elem, struct FuncKey **keyboard ) { KeySym keysym; KeyCode keycode; int context, mods ; int min = 0, max = 0 ; if( item == NULL ) return ; item->ok_to_free = 1; if( item == NULL || func_elem == NULL || keyboard == NULL ) return ; if( func_elem->term == NULL || func_elem->term->type != TT_FUNCTION ) return ; /* * Don't let a 0 keycode go through, since that means AnyKey to the * XGrabKey call in GrabKeys(). */ if( (keysym = XStringToKeysym (item->data.binding.sym)) == NoSymbol || (keycode = XKeysymToKeycode (dpy, keysym)) == 0) return ; XDisplayKeycodes (dpy, &min, &max); for (keycode = min; keycode <= max; keycode++) if (XKeycodeToKeysym (dpy, keycode, 0) == keysym) break; if (keycode > max) return ; context = item->data.binding.context ; mods = item->data.binding.mods ; if( !ReadConfigItem( item, func_elem ) ) return ; if( item->data.function ) { /* gotta add it to the keyboard hash */ FuncKey *tmp ; tmp = (FuncKey *) safecalloc (1, sizeof (FuncKey)); tmp->next = *keyboard; *keyboard = tmp ; tmp->name = mystrdup(item->data.binding.sym); tmp->keycode = keycode; tmp->cont = context; tmp->mods = mods; tmp->fdata = item->data.function; item->data.function = NULL ; } item->ok_to_free = (item->data.function != NULL); }
static GdkFilterReturn filter_mmkeys(GdkXEvent *xevent, GdkEvent *event, gpointer data) { XEvent *xev; XKeyEvent *key; Display *display; XmrWindow *window; GdkFilterReturn retv = GDK_FILTER_CONTINUE; xev = (XEvent *)xevent; if (xev->type != KeyPress) return GDK_FILTER_CONTINUE; key = (XKeyEvent *)xevent; window = (XmrWindow *)data; display = GDK_DISPLAY_XDISPLAY(gdk_display_get_default()); if (XKeysymToKeycode(display, XF86XK_AudioPlay) == key->keycode || XKeysymToKeycode(display, XF86XK_AudioPause) == key->keycode) { if (xmr_window_playing(window)) xmr_window_pause(window); else xmr_window_play(window); retv = GDK_FILTER_REMOVE; } else if (XKeysymToKeycode (display, XF86XK_AudioStop) == key->keycode) { xmr_window_pause(window); retv = GDK_FILTER_REMOVE; } else if (XKeysymToKeycode (display, XF86XK_AudioNext) == key->keycode) { xmr_window_play_next(window); retv = GDK_FILTER_REMOVE; } return retv; }
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; }
static bool x_key_pressed(x11_input_t *x11, int key) { if (key >= RETROK_LAST) return false; unsigned sym = input_translate_rk_to_keysym((enum retro_key)key); int keycode = XKeysymToKeycode(x11->display, sym); bool ret = x11->state[keycode >> 3] & (1 << (keycode & 7)); return ret; }
Bool is_key_pressed(Display *display, KeySym sym) { // determine if the key "sym" is pressed or not // this routine from "Introduction to the X Window System", 1989, p. 388 KeyCode code = XKeysymToKeycode(display, sym); if (code == NoSymbol) return false; char key_vector[32]; XQueryKeymap(display, key_vector); return (key_vector[code/8] >> (code&7)) & 1; }
void click_key(KeySym keysym) { KeyCode keycode = XKeysymToKeycode(main_window->display, keysym); XTestFakeKeyEvent(main_window->display, keycode, TRUE, 0); // key press event XTestFakeKeyEvent(main_window->display, keycode ,FALSE, 0); // key release event XFlush(main_window->display); return; }
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"); }
//Sends all words in the dictionary that can be formed by the given set of letters, then switches to the next //set of letters. void loop_through_dictionary( char* letters ) { int x; for( x = 0; x < NUM_WORDS; x++ ) { if( composed_of( dictionary[x], letters ) && strlen( dictionary[x]) < 6 ) { send_word( dictionary[x] ); } } sleep( 1 ); send_key( XKeysymToKeycode( display, XK_Control_L ) , 1); }
unsigned int X11Extras::getGroup1KeySym(unsigned int virtualkey) { unsigned int result = 0; Display *display = this->display(); unsigned int temp = XKeysymToKeycode(display, virtualkey); result = XkbKeycodeToKeysym(display, temp, 0, 0); return result; }