SkOSWindow::NextXEventResult SkOSWindow::nextXEvent() { XEvent evt; Display* dsp = fUnixWindow.fDisplay; if (!MyXNextEventWithDelay(dsp, &evt)) { return kContinue_NextXEventResult; } switch (evt.type) { case Expose: if (0 == evt.xexpose.count) { return kPaintRequest_NextXEventResult; } break; case ConfigureNotify: this->resize(evt.xconfigure.width, evt.xconfigure.height); break; case ButtonPress: if (evt.xbutton.button == Button1) this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kDown_State, NULL, getModi(evt)); break; case ButtonRelease: if (evt.xbutton.button == Button1) this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kUp_State, NULL, getModi(evt)); break; case MotionNotify: this->handleClick(evt.xmotion.x, evt.xmotion.y, SkView::Click::kMoved_State, NULL, getModi(evt)); break; case KeyPress: { int shiftLevel = (evt.xkey.state & ShiftMask) ? 1 : 0; KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, shiftLevel); if (keysym == XK_Escape) { return kQuitRequest_NextXEventResult; } this->handleKey(XKeyToSkKey(keysym)); long uni = keysym2ucs(keysym); if (uni != -1) { this->handleChar((SkUnichar) uni); } break; } case KeyRelease: this->handleKeyUp(XKeyToSkKey(XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0))); break; case ClientMessage: if ((Atom)evt.xclient.data.l[0] == wm_delete_window_message) { return kQuitRequest_NextXEventResult; } // fallthrough default: // Do nothing for other events break; } return kContinue_NextXEventResult; }
void SkOSWindow::loop() { Display* dsp = fUnixWindow.fDisplay; if (NULL == dsp) { return; } XSelectInput(dsp, fUnixWindow.fWin, EVENT_MASK); bool loop = true; XEvent evt; while (loop) { XNextEvent(dsp, &evt); switch (evt.type) { case Expose: if (evt.xexpose.count == 0) this->inval(NULL); break; case ConfigureNotify: this->resize(evt.xconfigure.width, evt.xconfigure.height); break; case ButtonPress: if (evt.xbutton.button == Button1) this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kDown_State); break; case ButtonRelease: if (evt.xbutton.button == Button1) this->handleClick(evt.xbutton.x, evt.xbutton.y, SkView::Click::kUp_State); break; case MotionNotify: this->handleClick(evt.xmotion.x, evt.xmotion.y, SkView::Click::kMoved_State); break; case KeyPress: { KeySym keysym = XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0); //SkDebugf("pressed key %i!\n\tKeySym:%i\n", evt.xkey.keycode, XKeycodeToKeysym(dsp, evt.xkey.keycode, 0)); if (keysym == XK_Escape) { loop = false; break; } this->handleKey(XKeyToSkKey(keysym)); long uni = keysym2ucs(keysym); if (uni != -1) { this->handleChar((SkUnichar) uni); } break; } case KeyRelease: //SkDebugf("released key %i\n", evt.xkey.keycode); this->handleKeyUp(XKeyToSkKey(XkbKeycodeToKeysym(dsp, evt.xkey.keycode, 0, 0))); break; case ClientMessage: if (SkEvent::ProcessEvent()) { this->post_linuxevent(); } break; default: // Do nothing for other events break; } } }
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); }
static char *next_state(const cmdp_token *token) { cmdp_state _next_state = token->next_state; if (token->next_state == __CALL) { const char *modifiers = get_string("modifiers"); int keycode = atoi(get_string("key")); int level = 0; if (modifiers != NULL && strstr(modifiers, "Shift") != NULL) { /* When shift is included, we really need to use the second-level * symbol (upper-case). The lower-case symbol could be on a * different key than the upper-case one (unlikely for letters, but * more likely for special characters). */ level = 1; /* Try to use the keysym on the first level (lower-case). In case * this doesn’t make it ambiguous (think of a keyboard layout * having '1' on two different keys, but '!' only on keycode 10), * we’ll stick with the keysym of the first level. * * This reduces a lot of confusion for users who switch keyboard * layouts from qwerty to qwertz or other slight variations of * qwerty (yes, that happens quite often). */ KeySym sym = XkbKeycodeToKeysym(dpy, keycode, 0, 0); if (!keysym_used_on_other_key(sym, keycode)) level = 0; } KeySym sym = XkbKeycodeToKeysym(dpy, keycode, 0, level); char *str = XKeysymToString(sym); const char *release = get_string("release"); char *res; char *modrep = (modifiers == NULL ? sstrdup("") : sstrdup(modifiers)); char *comma; while ((comma = strchr(modrep, ',')) != NULL) { *comma = '+'; } sasprintf(&res, "bindsym %s%s%s %s%s\n", (modifiers == NULL ? "" : modrep), (modifiers == NULL ? "" : "+"), str, (release == NULL ? "" : release), get_string("command")); clear_stack(); return res; } state = _next_state; /* See if we are jumping back to a state in which we were in previously * (statelist contains INITIAL) and just move statelist_idx accordingly. */ for (int i = 0; i < statelist_idx; i++) { if (statelist[i] != _next_state) continue; statelist_idx = i+1; return NULL; } /* Otherwise, the state is new and we add it to the list */ statelist[statelist_idx++] = _next_state; return NULL; }
void xu_key_ungrab(Window win, u_int mask, KeySym keysym) { KeyCode code; u_int i; code = XKeysymToKeycode(X_Dpy, keysym); if ((XkbKeycodeToKeysym(X_Dpy, code, 0, 0) != keysym) && (XkbKeycodeToKeysym(X_Dpy, code, 0, 1) == keysym)) mask |= ShiftMask; for (i = 0; i < nitems(ign_mods); i++) XUngrabKey(X_Dpy, code, (mask | ign_mods[i]), win); }
KeySym XKeycodeToKeysym(Display *dpy, #if NeedWidePrototypes unsigned int kc, #else KeyCode kc, #endif int col) { XkbDescRec *xkb; if (_XkbUnavailable(dpy)) return _XKeycodeToKeysym(dpy, kc, col); _XkbCheckPendingRefresh(dpy,dpy->xkb_info); xkb = dpy->xkb_info->desc; if ((kc<xkb->min_key_code)||(kc>xkb->max_key_code)) return NoSymbol; if (col>3) { int lastSym,tmp,nGrp; lastSym= 3; nGrp= XkbKeyNumGroups(xkb,kc); if ((nGrp>0)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup1Index))>2)) { if (col<=(lastSym+tmp-2)) return XkbKeycodeToKeysym(dpy,kc,XkbGroup1Index,col-lastSym+2); lastSym+= tmp-2; } if ((nGrp>1)&&((tmp=XkbKeyGroupWidth(xkb,kc,XkbGroup2Index))>2)) { if (col<=(lastSym+tmp-2)) return XkbKeycodeToKeysym(dpy,kc,XkbGroup2Index,col-lastSym+2); lastSym+= tmp-2; } if (nGrp>2) { tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup3Index); if (col<=lastSym+tmp) return XkbKeycodeToKeysym(dpy,kc,XkbGroup3Index,col-lastSym); lastSym+= tmp; } if (nGrp>3) { tmp= XkbKeyGroupWidth(xkb,kc,XkbGroup4Index); if (col<=lastSym+tmp) return XkbKeycodeToKeysym(dpy,kc,XkbGroup4Index,col-lastSym); } return NoSymbol; } return XkbKeycodeToKeysym(dpy,kc,(col>>1),(col&1)); }
void PressKey(wchar key, _XDisplay *dpy = NULL) { bool local = false; if (!dpy) { if (!(dpy = XOpenDisplay(NULL))) return; local = true; } wchar k = key; if (key > 0x00ff) key = key | 0x01000000; bool shift = false; KeyCode code = XKeysymToKeycode(dpy, key); if (code != 0) { if (XkbKeycodeToKeysym(dpy, code, 0, 0) != key) { if (XkbKeycodeToKeysym(dpy, code, 1, 0) == key) shift = true; else code = 0; } } else { int firstKeycode, maxKeycode; int keysymsPerKeycode; XDisplayKeycodes(dpy, &firstKeycode, &maxKeycode); KeySym *keysyms = XGetKeyboardMapping(dpy, firstKeycode, maxKeycode - firstKeycode + 1, &keysymsPerKeycode); int indx = (maxKeycode - firstKeycode - 1)*keysymsPerKeycode; keysyms[indx] = key; XChangeKeyboardMapping(dpy, firstKeycode, keysymsPerKeycode, keysyms, maxKeycode-firstKeycode); XSync(dpy, False); code = maxKeycode-1; if (XkbKeycodeToKeysym(dpy, code, 0, 0) != key) { if (XkbKeycodeToKeysym(dpy, code, 1, 0) == key) shift = true; } } if (code != 0) { if (shift) XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, XK_Shift_L), True, CurrentTime); XTestFakeKeyEvent(dpy, code, True, CurrentTime); XTestFakeKeyEvent(dpy, code, False, CurrentTime); if (shift) XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, XK_Shift_L), False, CurrentTime); } if (local) { XFlush(dpy); XCloseDisplay(dpy); } }
void xu_key_grab(Window win, unsigned int mask, KeySym keysym) { KeyCode code; unsigned int i; code = XKeysymToKeycode(X_Dpy, keysym); if ((XkbKeycodeToKeysym(X_Dpy, code, 0, 0) != keysym) && (XkbKeycodeToKeysym(X_Dpy, code, 0, 1) == keysym)) mask |= ShiftMask; for (i = 0; i < nitems(ign_mods); i++) XGrabKey(X_Dpy, code, (mask | ign_mods[i]), win, True, GrabModeAsync, GrabModeAsync); }
void handle_key (XCape_t* self, int key_event) { if ( key_event == KeyPress ) { g_debug ("Key Pressed!\n"); key_press_cnt++; } else { g_debug ("Key Released!\n"); if ( (key_press_cnt == 1) && (super_press) ) { /*if ( (key_press_cnt == 1) ) {*/ if ( is_grabbed () ) { return ; } KeySym key_sym; key_sym = XkbKeycodeToKeysym (self->ctrl_conn, self->key, 0, 0); gchar* key_str = g_strdup_printf ("%lu", (gulong)key_sym); if ( key_str ) { gchar* cmd = g_hash_table_lookup (key_table, key_str); if ( cmd ) { if ( system (cmd) == -1 ) { g_debug ("system exec error!"); } } g_free ( key_str); } } key_press_cnt = 0; super_press = False; } }
static int handle_special_keys(WindowInfo* info, XEvent* event, int down) { int keySym; if (!s_keyb_ext) return 0; keySym = XkbKeycodeToKeysym(s_display, event->xkey.keycode, 0, 1); switch (keySym) { case XK_KP_0: case XK_KP_1: case XK_KP_2: case XK_KP_3: case XK_KP_4: case XK_KP_5: case XK_KP_6: case XK_KP_7: case XK_KP_8: case XK_KP_9: case XK_KP_Separator: case XK_KP_Decimal: case XK_KP_Equal: case XK_KP_Enter: { if (info->key_callback) { info->key_callback(info->rust_data, keySym, down); return 1; } } } return 0; }
void TkpSetKeycodeAndState( Tk_Window tkwin, KeySym keySym, XEvent *eventPtr) { Display *display = Tk_Display(tkwin); int state; KeyCode keycode; if (keySym == NoSymbol) { keycode = 0; } else { keycode = XKeysymToKeycode(display, keySym); if (keycode != 0) { for (state = 0; state < 4; state++) { if (XkbKeycodeToKeysym(display, keycode, 0, state) == keySym){ if (state & 1) { eventPtr->xkey.state |= ShiftMask; } if (state & 2) { TkDisplay *dispPtr = ((TkWindow *) tkwin)->dispPtr; eventPtr->xkey.state |= dispPtr->modeModMask; } break; } } } } eventPtr->xkey.keycode = keycode; }
void XWindow::OnKeyRelease(WindowEventKey *e) { XkbStateRec s; Status st = XkbGetState(e->Handle()->display, XkbUseCoreKbd, &s); if (st != XkbOD_Success) throw new XException("Error getting xkb keyboard state", __FILE__, __LINE__, __func__); int shift = (s.mods & ShiftMask) != 0 ? 1 : 0; if (shift == 0) shift = (s.mods & Mod5Mask) != 0 ? 2 : 0; //int lock = (s.mods & LockMask) != 0 ? 1 : 0; //int ctrl = (s.mods & ControlMask) != 0 ? 1 : 0; //int mod1 = (s.mods & Mod1Mask) != 0 ? 1 : 0; //int mod2 = (s.mods & Mod2Mask) != 0 ? 1 : 0; //int mod3 = (s.mods & Mod3Mask) != 0 ? 1 : 0; //int mod4 = (s.mods & Mod4Mask) != 0 ? 1 : 0; //int mod5 = (s.mods & Mod5Mask) != 0 ? 1 : 0; KeySym keySym = XkbKeycodeToKeysym(e->Handle()->display, e->Handle()->keycode, 0, shift); char cadena[10]; int overflow = 0; int nbytes = XkbTranslateKeySym(e->Handle()->display, &keySym, s.mods, cadena, 10, &overflow); Text keyText = nbytes > 0 ? cadena : ""; ControlEventKey kr(*e, KeyCompositionSymbol(keySym, keyText)); // Key redirection until the focused control catches it bool redirected = false; for (int i=0; i<controls->Count() && !redirected; i++) redirected = (*controls)[i]->OnKeyRelease(&kr); DelegationOnKeyRelease().Execute(e); }
void keypress(XEvent *e) { int t; KeySym key = XkbKeycodeToKeysym(dpy,e->xkey.keycode,0,0); if (key == XK_q) running = False; else if (key == XK_Up || key == XK_equal || key == XK_k) { t = ww; wx -= ((ww*=1.1) - t)/2; t = wh; wy -= ((wh*=1.1) - t)/2; } else if (key == XK_Down || key == XK_minus || key == XK_j) { t = ww; wx += (t - (ww/=1.1))/2; t = wh; wy += (t - (wh/=1.1))/2; } else if (key == XK_Right || key == XK_l) { wx-=5; wy+=5; ww+=10; wh-=10; } else if (key == XK_Left || key == XK_h) { wx+=5; wy-=5; ww-=10; wh+=10; } else if (key == XK_r) { ww = iw; wh = ih; wx = ( sw > ww ? (sw-ww)/2 : 0); wy = ( sh > wh ? (sh-wh)/2 : 0); } else if (key == XK_s || (key == XK_f && (fullscreen=!fullscreen))) { scale = ( sw/(float)iw > sh/(float)ih ? sh/(float)ih : sw/(float)iw ); ww = iw * scale + 0.5; wh = ih * scale + 0.5; wx = (sw-ww)/2; wy = (sh-wh)/2; } else { return; } if (fullscreen) XMoveResizeWindow(dpy,win,0,0,sw,sh); else XMoveResizeWindow(dpy,win,wx,wy,ww,wh); XFlush(dpy); draw(); }
void init_modifier_keys() { int i, k = 0; int min_keycode, max_keycode, keysyms_per_keycode = 0; std::list<KeySym> Mod1MaskSyms, Mod2MaskSyms, Mod3MaskSyms, Mod4MaskSyms, Mod5MaskSyms; gXNumLockMask = 0; XModifierKeymap *map = XGetModifierMapping(XimServer::gDpy); XDisplayKeycodes(XimServer::gDpy, &min_keycode, &max_keycode); KeySym *sym = XGetKeyboardMapping(XimServer::gDpy, static_cast<KeyCode>(min_keycode), (max_keycode - min_keycode + 1), &keysyms_per_keycode); for (i = 0; i < 8; i++) { int j; for (j = 0; j < map->max_keypermod; j++) { if (map->modifiermap[k]) { KeySym ks; int index = 0; do { ks = XkbKeycodeToKeysym(XimServer::gDpy, map->modifiermap[k], 0, index); index++; } while (!ks && index < keysyms_per_keycode); switch (i) { case ShiftMapIndex: break; case LockMapIndex: break; case ControlMapIndex: break; case Mod1MapIndex: Mod1MaskSyms.push_back(ks); break; case Mod2MapIndex: Mod2MaskSyms.push_back(ks); break; case Mod3MapIndex: Mod3MaskSyms.push_back(ks); break; case Mod4MapIndex: Mod4MaskSyms.push_back(ks); break; case Mod5MapIndex: Mod5MaskSyms.push_back(ks); break; default: break; } // Check NumLock key if (ks == XK_Num_Lock) gXNumLockMask |= (1 << i); } k++; } } XFreeModifiermap(map); XFree(sym); gMod1Mask = check_modifier(Mod1MaskSyms); gMod2Mask = check_modifier(Mod2MaskSyms); gMod3Mask = check_modifier(Mod3MaskSyms); gMod4Mask = check_modifier(Mod4MaskSyms); gMod5Mask = check_modifier(Mod5MaskSyms); if (uim_scm_c_bool(uim_scm_callf("require-dynlib", "s", "xkb"))) uim_scm_callf("%xkb-set-display", "p", XimServer::gDpy); #if UIM_XIM_USE_JAPANESE_KANA_KEYBOARD_HACK // Init at here to sync with proper update timing although not a modifier. uim_x_kana_input_hack_init(XimServer::gDpy); #endif }
static void sorter(const char *cmd) { int i, j, n, nn = show->cur, grid, pn = -1; grid = (int) ceil(sqrt(show->nslides)); cairo_surface_t *t = cairo_image_surface_create(0, show->w, show->h); cairo_t *ctx = cairo_create(t); cairo_scale(ctx, MARGIN/(float)grid, MARGIN/(float)grid); cairo_translate(ctx, (show->w * (1-MARGIN))/2.0, (show->w * (1-MARGIN))/2.0); grab_mouse(); XEvent ev; XDefineCursor(dpy, wshow, None); while (True) { if (nn != pn) { pn = nn; cairo_set_source_rgba(ctx, 0, 0, 0, 1); cairo_paint(ctx); for (j = 0; j < grid; j++) for (i = 0; i < grid; i++) { if ( (n=j * grid + i) >= show->nslides ) break; cairo_set_source_surface(ctx, show->slide[n], (show->w * i)/MARGIN, (show->h * j)/MARGIN); cairo_paint_with_alpha(ctx,(n == nn ? 1.0 : 0.5)); } cairo_set_source_surface(show->target[0].ctx, t, 0, 0); cairo_paint(show->target[0].ctx); XFlush(dpy); } XMaskEvent(dpy,PointerMotionMask|ButtonPressMask|KeyPressMask,&ev); if (ev.type == KeyPress) { switch (XkbKeycodeToKeysym(dpy, ev.xkey.keycode, 0, 0)) { case 'h': case XK_Right: nn++; break; case 'j': case XK_Down: nn += grid; break; case 'k': case XK_Up: nn -= grid; break; case 'l': case XK_Left: nn--; break; case XK_space: case XK_Return: goto full_break_change; break; default: goto full_break_no_change; } if (nn < 0) nn = 0; else if (nn >= show->nslides) nn = show->nslides - 1; } else if (ev.type == ButtonPress) { if (ev.xbutton.button == 1) break; else if (ev.xbutton.button == 2) goto full_break_no_change; else if (ev.xbutton.button == 3) goto full_break_no_change; } else if (ev.type == MotionNotify) { nn = (ev.xbutton.y * grid / show->h) * grid + (ev.xbutton.x * grid / show->w); } } full_break_change: show->cur = nn; full_break_no_change: XUngrabKeyboard(dpy, CurrentTime); XUngrabPointer(dpy, CurrentTime); cairo_destroy(ctx); cairo_surface_destroy(t); XDefineCursor(dpy, wshow, invisible_cursor); draw(None); }
/* * 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 = XkbKeycodeToKeysym( x11->display, entry->code, 0, 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; }
void intercept(XPointer user_data, XRecordInterceptData *data) { XCape_t *self = (XCape_t*) user_data; static Bool mouse_pressed = False; KeyMap_t *km; if (data->category == XRecordFromServer) { int key_event = data->data[0]; KeyCode key_code = data->data[1]; if (self->debug) fprintf(stdout, "Intercepted key event %d, key code %d\n", key_event, key_code); for (km = self->map; km != NULL; km = km->next) { if ((km->UseKeyCode == False && XkbKeycodeToKeysym(self->ctrl_conn, key_code, 0, 0) == km->ks) || (km->UseKeyCode == True && key_code == km->kc)) { handle_key(self, km, mouse_pressed, key_event); } else if (km->pressed && key_event == KeyPress) { km->used = True; } } } }
uint32_t EventHandler::_getKey( XEvent& event ) { int index = 0; if( event.xkey.state & ShiftMask ) index = 1; const KeySym key = XkbKeycodeToKeysym( event.xany.display, event.xkey.keycode, 0, 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; } LBWARN << "Unrecognized X11 key code " << key << std::endl; return KC_VOID; } }
void ModifiersModule::updateWidgets() { if( m_pchkMacKeyboard->isChecked() ) { // If keys are swapped around to reflect MacOS norms: if( m_pchkMacSwap->isChecked() ) { m_plblCtrl->setText( i18n("Command") ); // Ctrl in Alt's place m_plblAlt->setText( i18n("Option") ); // Alt in Win's place m_plblWin->setText( i18n("Control") ); // Win in Ctrl's place } else { m_plblCtrl->setText( i18n("Control") ); // Ctrl labeled Control m_plblAlt->setText( i18n("Option") ); // Alt labeled Command m_plblWin->setText( i18n("Command") ); // Win labeled Option } m_pchkMacSwap->setEnabled( true ); } else { m_plblCtrl->setText( i18n(TQACCEL_OBJECT_NAME_STRING, "Ctrl") ); m_plblAlt->setText( i18n(TQACCEL_OBJECT_NAME_STRING, "Alt") ); m_plblWin->setText( i18n("Win") ); m_pchkMacSwap->setEnabled( false ); } XModifierKeymap* xmk = XGetModifierMapping( tqt_xdisplay() ); for( int iKey = m_plstXMods->columns()-1; iKey < xmk->max_keypermod; iKey++ ) m_plstXMods->addColumn( i18n("Key %1").arg(iKey+1) ); //int iModWinDef = -1; for( int iMod = 0; iMod < 8; iMod++ ) { // Find the default modifier index for the Win key. /*if( iMod > Mod2Index ) { uint symX = XkbKeycodeToKeysym( tqt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * iMod], 0, 0 ); if( symX == XK_Super_L || symX == XK_Super_R ) iModWinDef = iMod; else if( iModWinDef == -1 && (symX == XK_Meta_L || symX == XK_Meta_R) ) iModWinDef = iMod; }*/ // Insert items into X modifier map list for( int iKey = 0; iKey < xmk->max_keypermod; iKey++ ) { uint symX = XkbKeycodeToKeysym( tqt_xdisplay(), xmk->modifiermap[xmk->max_keypermod * iMod + iKey], 0, 0 ); m_plstXMods->itemAtIndex( iMod )->setText( 1 + iKey, XKeysymToString( symX ) ); } } XFreeModifiermap( xmk ); int i; switch( KKeyNative::modX(KKey::WIN) ) { case Mod2Mask: i = 2; break; case Mod3Mask: i = 3; break; case Mod4Mask: i = 4; break; case Mod5Mask: i = 5; break; default: i = 0; } if( i != 0 ) m_plblWinModX->setText( "mod" + TQString::number(i) ); else m_plblWinModX->setText( "<" + i18n("None") + ">" ); }
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); }
static void handle_key(XGenericEventCookie *cookie) { XIDeviceEvent *ev = (XIDeviceEvent *)cookie->data; qboolean down = cookie->evtype == XI_KeyPress; int keycode = ev->detail; unsigned time = Sys_XTimeToSysTime(ev->time); // Ignore shift_level for game key press KeySym keysym = XkbKeycodeToKeysym(x11display.dpy, keycode, 0, 0); int key = XLateKey( keysym ); // Set or clear 1 in the shift_level bitmask if ( keysym == XK_Shift_L || keysym == XK_Shift_R ) shift_level ^= (-down ^ shift_level) & 1; // Set or clear 2 in the shift_level bitmask else if( keysym == XK_ISO_Level3_Shift ) shift_level ^= (-down ^ shift_level) & 2; Key_Event(key, down, time); if( down ) { // Use shift_level for chat and console input qwchar wc = keysym2ucs(XkbKeycodeToKeysym(x11display.dpy, keycode, 0, shift_level)); if( wc == -1 && key > K_NUMLOCK && key <= KP_EQUAL ) wc = ( qwchar )key; // Convert ctrl-c / ctrl-v combinations to the expected events if( Key_IsDown(K_LCTRL) || Key_IsDown(K_RCTRL) ) { if( key == 'v' ) { key = CTRLV; wc = CTRLV; } else if( key == 'c' ) { key = CTRLC; wc = CTRLC; } } Key_CharEvent( key, wc ); } }
static void set_label_for_keycode(GtkWidget* label,gint code, GdkModifierType mods) { int keysym; gchar *key_text; if (code < 0) return; keysym = XkbKeycodeToKeysym(GDK_DISPLAY(), code, 0, 0); key_text = gtk_accelerator_name (keysym, mods); gtk_label_set_text(GTK_LABEL(label),key_text); g_free(key_text); }
void keypress(XEvent *e) { unsigned int i; XKeyEvent *ev = &e->xkey; KeySym keysym = XkbKeycodeToKeysym(dpy,(KeyCode)ev->keycode,0,0); for (i = 0; i < sizeof(keys)/sizeof(keys[0]); i++) if ( (keysym == keys[i].keysym) && keys[i].func && keys[i].mod == ((ev->state&~Mod2Mask)&~LockMask) ) keys[i].func(keys[i].arg); }
KeySym keycode_to_keysym(Display *dpy, KeyCode kc, int group, int level) { #if defined (WANT_XKB) && defined (HAVE_X11_XKBLIB_H) && defined (HAVE_XKBKEYCODETOKEYSYM) if (use_xkb) return XkbKeycodeToKeysym (dpy, kc, group, level); #endif (void) group; return XKeycodeToKeysym (dpy, kc, level); }
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; }
void kXneurApp::addUserAction::keyPressEvent(QKeyEvent *event) { QString key; QString md_key; key = QString("%1").arg(XKeysymToString(XkbKeycodeToKeysym(kXneurApp::xNeurConfig::dpy, event->nativeScanCode(),0,0))); md_key = modif(event->modifiers()); if(key.endsWith("_L") || key.endsWith("_R") ) key.remove(key.length()-2,2); ui->lblHotKey->setText(QString("%1%2").arg(md_key).arg(key)); }
void keypress(XEvent *ev) { int i; XKeyEvent *e = &ev->xkey; KeySym sym = XkbKeycodeToKeysym(dpy, e->keycode, 0, 0); for (i = 0; i < conf.nkeys; i++) { if( (sym==conf.key[i].keysym) && (conf.key[i].arg) && conf.key[i].mod == ((e->state&~Mod2Mask)&~LockMask) ) { command(conf.key[i].arg); } } }
void keypress(XEvent *e) { unsigned int i; KeySym keysym; XKeyEvent *ke; ke = &e->xkey; keysym = XkbKeycodeToKeysym(dpy, (KeyCode)ke->keycode, 0, 0); for (i = 0; i < LENGTH(keys); i++) { if (keysym == keys[i].keysym && keys[i].mod == ke->state && keys[i].func) keys[i].func(&(keys[i].arg)); } }
static void event_keypress(XEvent *e) { XKeyPressedEvent *ev = &e->xkey; KeySym keysym = XkbKeycodeToKeysym(EVDPY(e), (KeyCode)ev->keycode, 0, 0); struct keybind *k; screen_update_sel(); status_flush_surface(); SLIST_FOREACH(k, &W->h.keybind, next) if(k->keysym == keysym && KEYPRESS_MASK(k->mod) == KEYPRESS_MASK(ev->state)) if(k->func) k->func(k->cmd); }
void wait_key(void) { XEvent event; while(1) { XNextEvent(dpy, &event); if(event.type == KeyPress) { if(XkbKeycodeToKeysym(dpy, event.xkey.keycode, 0, 0) == opt_key) mainwindow_toggle(0); } } }