void event_callback(XPointer priv, XRecordInterceptData *hook) { /* FIXME: we need use XQueryPointer to get the first location */ static int cur_x = 0; static int cur_y = 0; if (hook->category != XRecordFromServer) { XRecordFreeData (hook); return; } XRecordDatum *data = (XRecordDatum*) hook->data; int event_type = data->type; BYTE btncode, keycode; btncode = keycode = data->event.u.u.detail; int rootx = data->event.u.keyButtonPointer.rootX; int rooty = data->event.u.keyButtonPointer.rootY; int time = hook->server_time; switch (event_type) { case KeyPress: /* if escape is pressed, stop the loop and clean up, then exit */ if (keycode == 9) stop = 1; /* Note: you should not use data_disp to do normal X operations !!!*/ printf ("KeyPress: \t%s\n", XKeysymToString(XKeycodeToKeysym(ctrl_disp, keycode, 0))); break; case KeyRelease: printf ("KeyRelease: \t%s\n", XKeysymToString(XKeycodeToKeysym(ctrl_disp, keycode, 0))); break; case ButtonPress: /* printf ("ButtonPress: /t%d, rootX=%d, rootY=%d", btncode, cur_x, cur_y); */ break; case ButtonRelease: /* printf ("ButtonRelease: /t%d, rootX=%d, rootY=%d", btncode, cur_x, cur_y); */ break; case MotionNotify: /* printf ("MouseMove: /trootX=%d, rootY=%d",rootx, rooty); */ cur_x = rootx; cur_y = rooty; break; case CreateNotify: break; case DestroyNotify: break; case NoExpose: break; case Expose: break; default: break; } printf (", time=%d\n", time); XRecordFreeData (hook); }
EAPI int ecore_x_test_fake_key_press(const char *key) { #ifdef ECORE_XTEST KeyCode keycode = 0; KeySym keysym = 0; int shift = 0; LOGFN(__FILE__, __LINE__, __FUNCTION__); if (!strncmp(key, "Keycode-", 8)) keycode = atoi(key + 8); else { keysym = XStringToKeysym(key); if (keysym == NoSymbol) return 0; keycode = XKeysymToKeycode(_ecore_x_disp, keysym); if (XKeycodeToKeysym(_ecore_x_disp, keycode, 0) != keysym) { if (XKeycodeToKeysym(_ecore_x_disp, keycode, 1) == keysym) shift = 1; else keycode = 0; } else shift = 0; } if (keycode == 0) { static int mod = 0; KeySym *keysyms; int keycode_min, keycode_max, keycode_num; int i; XDisplayKeycodes(_ecore_x_disp, &keycode_min, &keycode_max); keysyms = XGetKeyboardMapping(_ecore_x_disp, keycode_min, keycode_max - keycode_min + 1, &keycode_num); mod = (mod + 1) & 0x7; i = (keycode_max - keycode_min - mod - 1) * keycode_num; keysyms[i] = keysym; XChangeKeyboardMapping(_ecore_x_disp, keycode_min, keycode_num, keysyms, (keycode_max - keycode_min)); XFree(keysyms); XSync(_ecore_x_disp, False); keycode = keycode_max - mod - 1; } if (shift) XTestFakeKeyEvent(_ecore_x_disp, XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 1, 0); XTestFakeKeyEvent(_ecore_x_disp, keycode, 1, 0); XTestFakeKeyEvent(_ecore_x_disp, keycode, 0, 0); if (shift) XTestFakeKeyEvent(_ecore_x_disp, XKeysymToKeycode(_ecore_x_disp, XK_Shift_L), 0, 0); return 1; #else return 0; #endif }
// returned een string gemaakt van key en add (shift) char *key2string (int key, int add) { char soort[15], ascii[10]; if (XKeycodeToKeysym(display, key, 0) == XK_BackSpace) strcpy(ascii, "Backspace"); else sprintf(ascii, "%c", (int) XKeycodeToKeysym(display, key, 0)); switch (XKeycodeToKeysym(display, add, 0)) { case GDK_Control_L: case GDK_Control_R: strcpy(soort, "control - "); break; case GDK_Shift_L: case GDK_Shift_R: strcpy(soort, "shift - "); break; case GDK_Alt_L: strcpy(soort, "alt - "); break; default: strcpy(soort, ""); } sprintf(toetsen, "%s%s", soort, ascii); return toetsen; }
void MCScreenDC::getkeysdown(MCExecPoint &ep) { char kstring[U4L]; char km[32]; ep.clear(); MCmodifierstate = querymods(); XQueryKeymap(dpy, km); bool first = true; uint2 i; KeySym ksym; for (i = 0; i < 256; i++) { if (isKeyPressed(km, i)) { ksym = i; if (MCmodifierstate & MS_SHIFT || MCmodifierstate & MS_CAPS_LOCK) ksym = XKeycodeToKeysym(dpy, i, 1); else ksym = XKeycodeToKeysym(dpy, i, 0); if (ksym > 0) { ep.concatuint(ksym, EC_COMMA, first); first = false; } } } }
int HandleEvents() { #if 0 XEvent event; int ret = 0; if (XPending(dpy)) { do { XNextEvent(dpy, &event); switch(event.type) { case KeyPress: keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 1); ret = 1; break; case KeyRelease: keyboard_handler(XKeycodeToKeysym(dpy, event.xkey.keycode, 0), 0); ret = 0; break; case Expose: BlastScreen(); break; case ClientMessage: if (event.xclient.data.l[0] == wmDeleteWindow) Quit(NULL); break; default: break; } } while (XPending(dpy)); } return ret; #else return 0; #endif }
void ungrab_key (int key_code) { GdkWindow *root=gdk_get_default_root_window(); gdk_error_trap_push (); XUngrabKey (GDK_DISPLAY (), key_code, AnyModifier, (GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY()))); XUngrabKey (GDK_DISPLAY (), AnyKey, AnyModifier, (GDK_WINDOW_XID (root) ? GDK_WINDOW_XID (root) : DefaultRootWindow (GDK_DISPLAY()))); gdk_flush (); if (gdk_error_trap_pop ()) { gchar *error; gchar *key; key=g_strdup_printf ("%s",(XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (), key_code, 0)) != NULL)? XKeysymToString (XKeycodeToKeysym (GDK_DISPLAY (),key_code, 0)): g_strdup_printf ("%d",key_code)); error = g_strdup_printf (_("It seems that another application already has" " access to the multimedia keys.\n" "Key %s couldn't be bound.\n" "Is another daemon already running ?\n"), key); show_error(error); printf("[Sven][ERROR]:%s",error); g_free (key); g_free (error); } }
void update_key_ring (XPointer priv, XRecordInterceptData *data) { static int meta = 0; static int ctrl = 0; static int shift = 0; xEvent *event; KeySym ks; char *display_string; char *ksname; if (data->category==XRecordFromServer) { event=(xEvent *)data->data; /* display_keystack(keystack); */ switch (event->u.u.type) { case KeyPress: ks = XKeycodeToKeysym(d0, event->u.u.detail, 0); ksname = XKeysymToString (ks); /* TBD: Might have to handle no symbol keys */ if (! process_modifiers(ks, &meta, &ctrl, &shift, 1)) { display_string = create_emacs_keyname(ksname, meta, ctrl, shift); push(keystack, display_string); display_keystrokes(osd, keystack); } break; case KeyRelease: ks = XKeycodeToKeysym(d0, event->u.u.detail, 0); process_modifiers(ks, &meta, &ctrl, &shift, 0); break; } } }
bool KKeyNative::init(const KKey &key) { // Get any extra mods required by the sym. // E.g., XK_Plus requires SHIFT on the en layout. m_sym = key.sym(); uint modExtra = KKeyServer::Sym(m_sym).getModsRequired(); // Get the X modifier equivalent. if(!m_sym || !KKeyServer::modToModX(key.modFlags() | modExtra, m_mod)) { m_sym = m_mod = 0; m_code = 0; return false; } // XKeysymToKeycode returns the wrong keycode for XK_Print and XK_Break. // Specifically, it returns the code for SysReq instead of Print // Only do this for the default Xorg layout, other keycode mappings // (e.g. evdev) don't need or want it. if(m_sym == XK_Print && !(m_mod & Mod1Mask) && XKeycodeToKeysym(qt_xdisplay(), 111, 0) == XK_Print) m_code = 111; // code for Print else if(m_sym == XK_Break || ((m_sym == XK_Pause && (m_mod & ControlMask)) && XKeycodeToKeysym(qt_xdisplay(), 114, 0) == XK_Pause)) m_code = 114; else m_code = XKeysymToKeycode(qt_xdisplay(), m_sym); if(!m_code && m_sym) kdDebug(125) << "Couldn't get code for sym" << endl; // Now get the true sym formed by the modifiers // E.g., Shift+Equal => Plus on the en layout. if(key.modFlags() && ((m_sym < XK_Home || m_sym > XK_Begin) && m_sym != XK_Insert && m_sym != XK_Delete)) KKeyServer::codeXToSym(m_code, m_mod, m_sym); return true; }
bool GLWindow::GetEvent(Event &event){ if(XPending(dpy)){ XEvent xev; // Keyboard Key Press (Keysym code available in /usr/include/X11/keysymdef.h) if( XCheckWindowEvent(dpy, glWin, KeyPressMask, &xev) ) { event.type = TMGL_Press; KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0); MapKey(ks, event.input); } // Keyboard Key Release (Keysym code available in /usr/include/X11/keysymdef.h) else if(XCheckWindowEvent(dpy, glWin, KeyReleaseMask, &xev)) { event.type = TMGL_Release; KeySym ks = XKeycodeToKeysym(dpy, xev.xkey.keycode, 0); MapKey(ks, event.input); } // Mouse Button Press else if(XCheckWindowEvent(dpy, glWin, ButtonPressMask, &xev)) { event.type = TMGL_Press; MapMouse(xev.xbutton.button, event.input); } // Mouse Button Release else if(XCheckWindowEvent(dpy, glWin, ButtonReleaseMask, &xev)) { event.type = TMGL_Release; MapMouse(xev.xbutton.button, event.input); } // Mouse Motion else if(XCheckWindowEvent(dpy, glWin, PointerMotionMask, &xev)) { event.type = TMGL_Motion; event.motion.x = xev.xmotion.x; event.motion.y = xev.xmotion.y; } // Window Exposure else if(XCheckWindowEvent(dpy, glWin, ExposureMask, &xev)) { XWindowAttributes gwa; event.type = TMGL_Expose; XGetWindowAttributes(dpy, glWin, &gwa); event.expose.width = gwa.width; event.expose.height = gwa.height; } // Other Events else { return false; } return true; } return false; }
ENTRYPOINT Bool hypertorus_handle_event(ModeInfo *mi, XEvent *event) { Display *display = MI_DISPLAY(mi); hypertorusstruct *hp = &hyper[MI_SCREEN(mi)]; KeySym sym; if (event->xany.type == ButtonPress && event->xbutton.button == Button1) { hp->button_pressed = True; gltrackball_start(hp->trackballs[hp->current_trackball], event->xbutton.x, event->xbutton.y, MI_WIDTH(mi), MI_HEIGHT(mi)); return True; } else if (event->xany.type == ButtonRelease && event->xbutton.button == Button1) { hp->button_pressed = False; return True; } else if (event->xany.type == KeyPress) { sym = XKeycodeToKeysym(display,event->xkey.keycode,0); if (sym == XK_Shift_L || sym == XK_Shift_R) { hp->current_trackball = 1; if (hp->button_pressed) gltrackball_start(hp->trackballs[hp->current_trackball], event->xbutton.x, event->xbutton.y, MI_WIDTH(mi), MI_HEIGHT(mi)); return True; } } else if (event->xany.type == KeyRelease) { sym = XKeycodeToKeysym(display,event->xkey.keycode,0); if (sym == XK_Shift_L || sym == XK_Shift_R) { hp->current_trackball = 0; if (hp->button_pressed) gltrackball_start(hp->trackballs[hp->current_trackball], event->xbutton.x, event->xbutton.y, MI_WIDTH(mi), MI_HEIGHT(mi)); return True; } } else if (event->xany.type == MotionNotify && hp->button_pressed) { gltrackball_track(hp->trackballs[hp->current_trackball], event->xmotion.x, event->xmotion.y, MI_WIDTH(mi), MI_HEIGHT(mi)); return True; } return False; }
int main(int argc, char **argv) { Display *display; XEvent xevent; Window window; if( (display = XOpenDisplay(NULL)) == NULL ) return -1; window = DefaultRootWindow(display); XAllowEvents(display, AsyncBoth, CurrentTime); XGrabPointer(display, window, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask , GrabModeAsync, GrabModeAsync, None, None, CurrentTime); XGrabKeyboard(display, window, false, GrabModeAsync, GrabModeAsync, CurrentTime); while(1) { XNextEvent(display, &xevent); int mykey; switch (xevent.type) { case MotionNotify: printf("Mouse move : [%d, %d]\n", xevent.xmotion.x_root, xevent.xmotion.y_root); break; case ButtonPress: printf("Button pressed : %s, %d\n", key_name[xevent.xbutton.button - 1], xevent.xbutton.button); break; case ButtonRelease: printf("Button released : %s, %d\n", key_name[xevent.xbutton.button - 1], xevent.xbutton.button); break; case KeyPress: mykey = XKeycodeToKeysym(display, xevent.xkey.keycode, 0); printf("KeyPress : %s, %d\n", XKeysymToString(mykey), mykey); if (xevent.xkey.keycode == 27 || xevent.xkey.keycode == 9) { return 0; } break; case KeyRelease: mykey = XKeycodeToKeysym(display, xevent.xkey.keycode, 0); printf("KeyRelease : %s, %d\n", XKeysymToString(mykey), mykey); break; } } return 0; }
int main(void) { Display *d; Window w; XEvent e; KeySym key; int s; d = XOpenDisplay(NULL); if (d == NULL) { fprintf(stderr, "Cannot open display\n"); exit(1); } s = DefaultScreen(d); w = XCreateSimpleWindow(d, RootWindow(d, s), 10, 10, 200, 200, 1, BlackPixel(d, s), WhitePixel(d, s)); XSelectInput(d, w, ExposureMask | KeyPressMask | KeyReleaseMask); XMapWindow(d, w); XGrabKeyboard(d, DefaultRootWindow(d), True, GrabModeAsync, GrabModeAsync, CurrentTime); while (1) { XNextEvent(d, &e); if (e.type == KeyPress) { key = XKeycodeToKeysym(d, e.xkey.keycode, 0); } else if (e.type == KeyRelease) { key = XKeycodeToKeysym(d, e.xkey.keycode, 0); printf("Release: %c\n", key); // This is really a hack since it does not correctly handle non-alnum keys. if(txtidx > 0) { txtidx--; } memmove(txtbuf, txtbuf+1, sizeof(txtbuf)-2); txtbuf[sizeof(txtbuf)-2] = (char)key; TrySpellcheck(d, key); } if (e.type == KeyPress) { key = XKeycodeToKeysym(d, e.xkey.keycode, 0); if (key == XK_Alt_L) { // Exit on pressing Alt break; } } } XUngrabKeyboard(d, CurrentTime); XCloseDisplay(d); return 0; }
void tela_processa_eventos(tela_t *tela) { /* processa eventos do servidor X, atualizando a posicao do mouse * e ultima tecla pressionada na variavel da tela-> */ XEvent evento; XButtonEvent *be = (XButtonEvent *) & evento; XMotionEvent *me = (XMotionEvent *) & evento; XKeyEvent *ke = (XKeyEvent *) & evento; while (XCheckMaskEvent(tela->display, EVENT_MASK, &evento) == True) { switch (evento.type) { case ButtonPress: if (be->button == 1) tela->botao = true; break; case ButtonRelease: if (be->button == 1) tela->botao = false; break; case MotionNotify: tela->rato.x = XX2U(me->x); tela->rato.y = YX2U(me->y); break; case KeyPress: // se a tecla anterior nao foi lida, e' perdida tela->tecla = XKeycodeToKeysym(tela->display, ke->keycode, 0); break; case KeyRelease: break; } } }
static void translate_key_event (ClutterBackend *backend, ClutterEvent *event, XEvent *xevent) { char buffer[256+1]; int n; CLUTTER_NOTE (EVENT, "Translating key %s event", xevent->xany.type == KeyPress ? "press" : "release"); event->key.time = xevent->xkey.time; event->key.modifier_state = (ClutterModifierType) xevent->xkey.state; event->key.hardware_keycode = xevent->xkey.keycode; /* keyval is the key ignoring all modifiers ('1' vs. '!') */ event->key.keyval = XKeycodeToKeysym (xevent->xkey.display, xevent->xkey.keycode, 0); /* unicode_value is the printable representation */ n = XLookupString (&xevent->xkey, buffer, sizeof (buffer) - 1, NULL, NULL); if (n != NoSymbol) { event->key.unicode_value = g_utf8_get_char_validated (buffer, n); if ((event->key.unicode_value != -1) && (event->key.unicode_value != -2)) return; } event->key.unicode_value = (gunichar)'\0'; }
static void mapping_busy_key(int timeout) { int i; unsigned char keymap[32]; static unsigned int masktable[8] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }; XQueryKeymap (dpy, (char *) keymap); fprintf (stderr, "%s: please release the following keys within %d seconds:\n", ProgramName, timeout); for (i = 0; i < 256; i++) { if (keymap[i >> 3] & masktable[i & 7]) { KeySym ks = XKeycodeToKeysym (dpy, (KeyCode) i, 0); char *cp = XKeysymToString (ks); fprintf (stderr, " %s (keysym 0x%x, keycode %d)\n", cp ? cp : "UNNAMED", (unsigned int)ks, i); } } sleep (timeout); return; }
Bool keydown(wm_t *wm, wm_event_t *event) { XKeyEvent kev = event->xevent->xkey; KeySym sym; wm_log(wm, LOG_INFO, "%s", __func__); sym = XKeycodeToKeysym(wm->dpy, kev.keycode, 0); wm_log(wm, LOG_INFO, "%s: key %d / %d", __func__, sym, XK_j); if (kev.state == Mod1Mask) { switch (sym) { case XK_j: container_split(current_container, SPLIT_VERTICAL); break; case XK_h: container_split(current_container, SPLIT_HORIZONTAL); break; default: wm_log(wm, LOG_WARN, "%s: unexpected keysym %d", __func__, sym); } } switch (sym) { case XK_Return: run("xterm -bg black -fg white"); break; } XUngrabServer(wm->dpy); return True; }
std::string keypress_str() { if (e.type == KeyPress) return XKeysymToString(XKeycodeToKeysym(dpy,e.xkey.keycode,0)); return "0"; }
/* * Fetch one entry from the device's keymap if supported. * this does a fake mapping based on the orginal DFB code */ static DFBResult driver_get_keymap_entry( CoreInputDevice *device, void *driver_data, DFBInputDeviceKeymapEntry *entry ) { int i; X11InputData *data = driver_data; DFBX11 *x11 = data->x11; XLockDisplay( x11->display ); for (i=0; i<4; i++) { KeySym xSymbol = XKeycodeToKeysym( x11->display, entry->code, i ); if (i == 0) entry->identifier = xsymbol_to_id( xSymbol ); entry->symbols[i] = xsymbol_to_symbol( xSymbol ); } XUnlockDisplay( x11->display ); /* is CapsLock effective? */ if (entry->identifier >= DIKI_A && entry->identifier <= DIKI_Z) entry->locks |= DILS_CAPS; /* is NumLock effective? */ if (entry->identifier >= DIKI_KP_DECIMAL && entry->identifier <= DIKI_KP_9) entry->locks |= DILS_NUM; return DFB_OK; }
int GetKey(void) { long keysym; lastKey=NO_KEY; handleEvents(); if (lastKey!=NO_KEY) { keysym=(long)XKeycodeToKeysym(display,lastKey,0); switch (keysym & 0x0000FFFF) { case 65505: // left shift case 65506: // right shift case 65507: // left ctrl case 65508: // right ctrl case 65513: // left alt case 65514: // right alt return NO_KEY; case 65293: // enter case 65421: // num enter return 13; case 65288: // backspace return 8; case 65289: // tab return 9; } return (int)(keysym & 0x0000FFFF); } else { return NO_KEY; } }
/* we need a keycode + modifier to generate the proper keysym (such as @). Return 1 if successful, 0 otherwise. This function can fail if a keysym doesn't map to a keycode. */ static int keysym_to_keycode_mod (KeySym keysym, KeyCode *code, unsigned int *mod) { KeySym lower, upper; *mod = 0; *code = XKeysymToKeycode (dpy, keysym); lower = XKeycodeToKeysym (dpy, *code, 0); upper = XKeycodeToKeysym (dpy, *code, 1); /* If you need to press shift to get the keysym, add the shift mask. */ if (upper == keysym && lower != keysym) *mod = ShiftMask; return *code != 0; }
void UModifier::mapKeys(UDisp* d) { static bool mods_init = false; if (mods_init) return; mods_init = true; Display* sysdisp = ((UDispX11*)d)->getSysDisp(); _MetaDown = Mod1Mask; // valeur qui peut varier suivant les plateformes _AltDown = Mod2Mask; // idem _ModeSwitch = 0; // cf a la fin _MetaDown = _AltDown = _ModeSwitch = 0; XModifierKeymap* modmap = XGetModifierMapping(sysdisp); if (!modmap) return; // 8 modifiers dans tous les cas de figures (definis ou pas) for (int m = 0; m < 8; m++) { // plusieurs keycodes par modifiers, de 0 a max_keypermod for (int c = 0; c < modmap->max_keypermod; c++) { KeyCode keycode = modmap->modifiermap[m * modmap->max_keypermod + c]; if (keycode != 0) { KeySym keysym = XKeycodeToKeysym(sysdisp, keycode, 0); if (keysym == XK_Meta_L || keysym == XK_Meta_R) _MetaDown = (1 << m); else if (keysym == XK_Alt_L || keysym == XK_Alt_R) _AltDown = (1 << m); else if (keysym == XK_Mode_switch) _ModeSwitch = (1 << m); } } } XFreeModifiermap(modmap); }
void Window::Run(){ running = true; while (running) { //struct timeval timeNow; while (XPending(display)) { XEvent ev; XNextEvent(display, &ev); switch (ev.type) { case KeyPress: { unsigned int keycode, keysym; keycode = ((XKeyEvent *)&ev)->keycode; keysym = XKeycodeToKeysym(display, keycode, 0); if (keysym == XK_Return || keysym == XK_Escape) running = false; } break; } } if (running) { //gettimeofday(&timeNow, NULL); //appRender(timeNow.tv_sec * 1000 + timeNow.tv_usec / 1000, // sWindowWidth, sWindowHeight); //checkGLErrors(); //eglSwapBuffers(sEglDisplay, sEglSurface); //checkEGLErrors(); } } }
void print_key (Display * d, Keys_t * key) { char str[STR_KEY_LEN]; if (verbose) { if (key->type == SYM) { modifier_to_string (key->modifier, str); printf ("\"%s\"\n %s%s%s%s\n", key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ), key->event_type == PRESS ? "" : "Release + ", str, str[0] ? " + " : "", XKeysymToString (key->key.sym)); } else if (key->type == BUTTON) { printf ("\"%s\"\n %sm:0x%x + b:%d (mouse)\n", key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ), key->event_type == PRESS ? "" : "Release + ", key->modifier, key->key.button); } else { printf ("\"%s\"\n %sm:0x%x + c:%d\n", key->command != NULL ? key->command : ( key->function != 0 ? "(Scheme function)" : "NoCommand" ), key->event_type == PRESS ? "" : "Release + ", key->modifier, key->key.code); if (d != NULL) { modifier_to_string (key->modifier, str); printf (" %s%s%s%s\n", str, str[0] ? " + " : "", key->event_type == PRESS ? "" : "Release + ", (XKeysymToString (XKeycodeToKeysym (d, key->key.code, 0)) != NULL) ? XKeysymToString (XKeycodeToKeysym (d, key->key. code, 0)) : "NoSymbol"); } } } }
uint32_t GLXEventHandler::_getKey( XEvent& event ) { int index = 0; if( event.xkey.state & ShiftMask ) index = 1; const KeySym key = XKeycodeToKeysym( event.xany.display, event.xkey.keycode, index ); switch( key ) { case XK_Escape: return KC_ESCAPE; case XK_BackSpace: return KC_BACKSPACE; case XK_Return: return KC_RETURN; case XK_Tab: return KC_TAB; case XK_Home: return KC_HOME; case XK_Left: return KC_LEFT; case XK_Up: return KC_UP; case XK_Right: return KC_RIGHT; case XK_Down: return KC_DOWN; case XK_Page_Up: return KC_PAGE_UP; case XK_Page_Down: return KC_PAGE_DOWN; case XK_End: return KC_END; case XK_F1: return KC_F1; case XK_F2: return KC_F2; case XK_F3: return KC_F3; case XK_F4: return KC_F4; case XK_F5: return KC_F5; case XK_F6: return KC_F6; case XK_F7: return KC_F7; case XK_F8: return KC_F8; case XK_F9: return KC_F9; case XK_F10: return KC_F10; case XK_F11: return KC_F11; case XK_F12: return KC_F12; case XK_F13: return KC_F13; case XK_F14: return KC_F14; case XK_F15: return KC_F15; case XK_F16: return KC_F16; case XK_F17: return KC_F17; case XK_F18: return KC_F18; case XK_F19: return KC_F19; case XK_F20: return KC_F20; case XK_Shift_L: return KC_SHIFT_L; case XK_Shift_R: return KC_SHIFT_R; case XK_Control_L: return KC_CONTROL_L; case XK_Control_R: return KC_CONTROL_R; case XK_Alt_L: return KC_ALT_L; case XK_Alt_R: return KC_ALT_R; default: if( (key >= XK_space && key <= XK_asciitilde ) || (key >= XK_nobreakspace && key <= XK_ydiaeresis)) { return key; } EQWARN << "Unrecognized X11 key code " << key << std::endl; return KC_VOID; } }
unsigned long wrapXkbKeycodeToKeysym(Display *pDisplay, unsigned char cCode, unsigned int cGroup, unsigned int cIndex) { KeySym cSym = XkbKeycodeToKeysym(pDisplay, cCode, cGroup, cIndex); if (cSym != NoSymbol) return cSym; return XKeycodeToKeysym(pDisplay, cCode, cGroup * 2 + cIndex % 2); }
// Determine if an X11 keycode is currently mapped to one or more keysyms. static bool keycodeInUse(Display *dpy, int keycode) { for (int index = 0; index < 8; ++index) { if (XKeycodeToKeysym(dpy, keycode, index) != NoSymbol) return true; } return false; }
bool CXWindowsPrimaryScreen::isLockedToScreen() const { CDisplayLock display(m_screen); // query the pointer to get the button state Window root, window; int xRoot, yRoot, xWindow, yWindow; unsigned int state; if (XQueryPointer(display, m_window, &root, &window, &xRoot, &yRoot, &xWindow, &yWindow, &state)) { if ((state & (Button1Mask | Button2Mask | Button3Mask | Button4Mask | Button5Mask)) != 0) { LOG((CLOG_DEBUG "locked by mouse button")); return true; } } // get logical keyboard state char keyMap[32]; memset(keyMap, 0, sizeof(keyMap)); XQueryKeymap(display, keyMap); // locked if any key is down for (unsigned int i = 0; i < sizeof(keyMap); ++i) { if (keyMap[i] != 0) { for (unsigned int j = 0; j < 8; ++j) { if ((keyMap[i] & (1 << j)) != 0) { const KeyCode keycode = 8 * i + j; const KeySym keysym = XKeycodeToKeysym(display, keycode, 0); // if any key is half-duplex then it'll be down when // toggled on but shouldn't count as a reason to lock // to the screen. if (m_numLockHalfDuplex && keysym == XK_Num_Lock) { continue; } if (m_capsLockHalfDuplex && keysym == XK_Caps_Lock) { continue; } // non-half-duplex key down char* name = XKeysymToString(keysym); if (name == NULL) { LOG((CLOG_DEBUG "locked by keycode %d", keycode)); } else { LOG((CLOG_DEBUG "locked by \"%s\"", name)); } return true; } } } } // not locked return false; }
VisKeySym *lv_x11_key_lookup (LVX11Key *x11key, Display *display, XKeyEvent *xkey, KeyCode kc, VisKeySym *keysym, int pressed) { KeySym xsym; /* Get the raw keyboard scancode */ // keysym->scancode = kc; xsym = XKeycodeToKeysym(display, kc, 0); #ifdef DEBUG_KEYS fprintf(stderr, "Translating key 0x%.4x (%d)\n", xsym, kc); #endif /* Get the translated SDL virtual keysym */ keysym->sym = VKEY_UNKNOWN; if ( xsym ) { switch (xsym>>8) { case 0x1005FF: #ifdef SunXK_F36 if ( xsym == SunXK_F36 ) keysym->sym = VKEY_F11; #endif #ifdef SunXK_F37 if ( xsym == SunXK_F37 ) keysym->sym = VKEY_F12; #endif break; case 0x00: /* Latin 1 */ case 0x01: /* Latin 2 */ case 0x02: /* Latin 3 */ case 0x03: /* Latin 4 */ case 0x04: /* Katakana */ case 0x05: /* Arabic */ case 0x06: /* Cyrillic */ case 0x07: /* Greek */ case 0x08: /* Technical */ case 0x0A: /* Publishing */ case 0x0C: /* Hebrew */ case 0x0D: /* Thai */ keysym->sym = (VisKey)(xsym&0xFF); /* Map capital letter syms to lowercase */ if ((keysym->sym >= 'A')&&(keysym->sym <= 'Z')) keysym->sym += ('a'-'A'); break; case 0xFE: keysym->sym = x11key->ODD_keymap[xsym&0xFF]; break; case 0xFF: keysym->sym = x11key->MISC_keymap[xsym&0xFF]; break; default: fprintf(stderr, "X11: Unknown xsym, sym = 0x%04x\n", (unsigned int)xsym); break; } } else { /* X11 doesn't know how to translate the key! */ switch (kc) {
/* static */ KeySym nsKeyCode::ConvertKeyCodeToKeySym(Display * aDisplay, KeyCode aKeyCode) { KeySym keysym = 0; keysym = XKeycodeToKeysym(aDisplay, aKeyCode, 0); return keysym; }
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); }