static PyObject * virtkey_get_keysyms_from_keycode_internal(virtkey *cvirt, long keycode, const long* mod_masks, int num_masks) { static const long mods[] = {0}; int m; unsigned int mods_rtn; KeySym keysym = 0; if (mod_masks == NULL) { mod_masks = mods; num_masks = (sizeof(mods)/sizeof(*mods)); } PyObject* tuple = PyTuple_New(num_masks); /* get effective group index */ XkbStateRec state; int group = 0; if (Success == XkbGetState(cvirt->display, XkbUseCoreKbd, &state) && XkbIsLegalGroup(state.locked_group)) /* be defensive */ group = state.locked_group; for(m = 0; m < num_masks; m++) { if (!XkbTranslateKeyCode (cvirt->kbd, (KeyCode) keycode, XkbBuildCoreState (mod_masks[m], group), &mods_rtn, &keysym)){ keysym = 0; } PyTuple_SetItem(tuple, m, PyLong_FromLong(keysym)); } return tuple; }
int main(void) { int evCode, errRet, rsnRet; int maj = XkbMajorVersion; int min = XkbMinorVersion; Display* disp = XkbOpenDisplay("", &evCode, &errRet, &maj, &min, &rsnRet); // State XkbStatePtr state = calloc(1, sizeof(XkbStateRec)); XkbGetState(disp, 0x100, state); // Names XkbDescPtr desc = XkbAllocKeyboard(); XkbGetNames(disp, XkbSymbolsNameMask, desc); Atom symNameAtom = desc->names->symbols; char* layouts = XGetAtomName(disp, symNameAtom); printf("%s\n", getActiveLayout(layouts, state->group)); unsigned int mask = XkbStateNotifyMask; XkbSelectEvents(disp, XkbUseCoreKbd, mask, mask); XkbEvent event; while (1) { XNextEvent(disp, &event.core); if (event.state.changed & 0x90) printf("%s\n", getActiveLayout(layouts, event.state.group)); } }
int main(int argc, char *argv[]) { Display *dpy; int res; XkbStateRec state; dpy = XOpenDisplay(NULL); if (!dpy) {fputs("Can't open display\n", stderr); exit(1);} res = XkbQueryExtension(dpy, NULL, NULL, NULL, NULL, NULL); if (!res) {fputs("Can't init XKB\n", stderr); exit(1);} XkbGetState(dpy, XkbUseCoreKbd, &state); if ( ShiftMask & state.mods ) fputs("+Shift", stdout); if ( LockMask & state.mods ) fputs("+Lock", stdout); if ( ControlMask & state.mods ) fputs("+Control", stdout); if ( Mod1Mask & state.mods ) fputs("+Mod1", stdout); if ( Mod2Mask & state.mods ) fputs("+Mod2", stdout); if ( Mod3Mask & state.mods ) fputs("+Mod3", stdout); if ( Mod4Mask & state.mods ) fputs("+Mod4", stdout); if ( Mod5Mask & state.mods ) fputs("+Mod5", stdout); XCloseDisplay(dpy); return 0; }
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); }
static gboolean is_shift_pressed (void) { gboolean ret; XkbStateRec state; Bool status; ret = FALSE; gdk_error_trap_push (); status = XkbGetState (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), XkbUseCoreKbd, &state); #if GTK_CHECK_VERSION(3,0,0) gdk_error_trap_pop_ignored (); #else gdk_error_trap_pop (); #endif if (status == Success) { ret = state.mods & ShiftMask; } return ret; }
unsigned int detect_keyboard_layout_from_xkb(void *dpy) { char *layout, *variant; unsigned int keyboard_layout = 0, group = 0; XkbRF_VarDefsRec rules_names; XKeyboardState coreKbdState; XkbStateRec state; DEBUG_KBD("display: %p", dpy); if (dpy && XkbRF_GetNamesProp(dpy, NULL, &rules_names)) { DEBUG_KBD("layouts: %s", rules_names.layout); DEBUG_KBD("variants: %s", rules_names.variant); XGetKeyboardControl(dpy, &coreKbdState); if (XkbGetState(dpy, XkbUseCoreKbd, &state) == Success) group = state.group; DEBUG_KBD("group: %d", state.group); layout = comma_substring(rules_names.layout, group); variant = comma_substring(rules_names.variant, group); DEBUG_KBD("layout: %s", layout); DEBUG_KBD("variant: %s", variant); keyboard_layout = find_keyboard_layout_in_xorg_rules(layout, variant); free(rules_names.model); free(rules_names.layout); free(rules_names.variant); free(rules_names.options); } return keyboard_layout; }
static PyObject * virtkey_get_current_group(PyObject * self, PyObject * noargs) { PyObject * result = NULL; virtkey * cvirt = (virtkey *)self; Display * display = cvirt->display; /* get current group index */ XkbStateRec state; if (Success != XkbGetState(display, XkbUseCoreKbd, &state)) PyErr_SetString(virtkey_error, "XkbGetState failed"); else{ int group = state.locked_group; if (!XkbIsLegalGroup(group)) /* be defensive */ PyErr_SetString(virtkey_error, "invalid effective group"); else { result = PyInt_FromLong(group); } } if (PyErr_Occurred()) return NULL; if (!result) Py_RETURN_NONE; return result; }
TEST_F(CXWindowsKeyStateTests, pollActiveGroup_xkb_areEqual) { #if HAVE_XKB_EXTENSION CMockKeyMap keyMap; CMockEventQueue eventQueue; CXWindowsKeyState keyState( m_display, true, (IEventQueue&)keyMap, (CKeyMap&)eventQueue); // reset the group keyState.m_group = -1; XkbStateRec state; // compare pollActiveGroup() with XkbGetState() if (XkbGetState(m_display, XkbUseCoreKbd, &state) == Success) { SInt32 actual = keyState.pollActiveGroup(); ASSERT_EQ(state.group, actual); } else { FAIL() << "XkbGetState() returned error " << errno; } #else SUCCEED() << "Xkb extension not installed"; #endif }
int get_modifier(int mod) { XkbStateRec xkbState; Display* display = XOpenDisplay(NULL); XkbGetState(display, XkbUseCoreKbd, &xkbState); XCloseDisplay(display); return xkbState.locked_mods & mod; }
gboolean get_caps_lock_state() { XkbStateRec states; if (XkbGetState(GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), XkbUseCoreKbd, &states) == Success) { if (states.locked_mods & LockMask) return TRUE; } return FALSE; }
int main (int argc, char *argv[]) { Display *dpy; XkbStateRec xkbState; int group, newgroup; char *endptr; if (argc > 2 || argc == 2 && (0 == strcmp(argv[1], "--help") || 0 == strcmp(argv[1], "-h"))) { fprintf(stderr, "Usage: %s [group]\n", argv[0]); exit(EXIT_FAILURE); } dpy = XkbOpenDisplay(NULL, NULL, NULL, NULL, NULL, NULL); if (NULL == dpy) { fprintf (stderr, "%s: Can't open display\n", argv[0]); exit(EXIT_FAILURE); } XkbGetState(dpy, XkbUseCoreKbd, &xkbState); group = xkbState.group; switch (argc) { case 1: fprintf (stdout, "%d\n", group); goto success; break; case 2: errno = 0; newgroup = strtol(argv[1], &endptr, 10); if (errno != 0 || *endptr != '\0') { fprintf(stderr, "The first argument must be an integer\n"); goto failure; } if (newgroup != group) { if (False == XkbLockGroup(dpy, XkbUseCoreKbd, abs (newgroup % 4))) { fprintf(stderr, "%s: Can't lock group\n", argv[0]); goto failure; } XSync(dpy, False); } break; } success: XCloseDisplay(dpy); exit(EXIT_SUCCESS); failure: XCloseDisplay(dpy); exit(EXIT_FAILURE); }
char* xkbGetGroup(char* buf, int len) { int xkbEventType, xkbError, reason_rtrn, mjr, mnr; char *display_name; XkbStateRec xkbstate; static Display *dpy = NULL; static XkbDescPtr xkbdesc = NULL; /* Lets begin */ if (!dpy) { display_name = NULL; mjr = XkbMajorVersion; mnr = XkbMinorVersion; dpy = XkbOpenDisplay(display_name, &xkbEventType, &xkbError, &mjr, &mnr, &reason_rtrn); } if (dpy == NULL) { strcpy(buf, "?"); return buf; } if ( Success != XkbGetState(dpy, XkbUseCoreKbd, &xkbstate) ) { strcpy(buf, "?"); return buf; } if (!xkbdesc) xkbdesc = XkbAllocKeyboard(); if (!xkbdesc) { strcpy(buf, "?"); return buf; } /* get the names of the layout */ if ( Success == XkbGetNames(dpy, 1<<12, xkbdesc)) { Atom iatoms[4]; char *iatomnames[4]; int i, j; for (i = 0, j = 0; i < 4; i++) if (xkbdesc->names->groups[i] != None) iatoms[j++] = xkbdesc->names->groups[i]; if (XGetAtomNames(dpy, iatoms, j, iatomnames)) buf = strndup(iatomnames[xkbstate.locked_group], len); } return buf; }
int xkb_state() { unsigned int mask; unsigned int numlockState; XkbStateRec xkbState; if( !xkb_init()) return 0; mask = xkb_numlock_mask(); if( mask == 0 ) return 0; XkbGetState( dpy, XkbUseCoreKbd, &xkbState); numlockState = xkbState.locked_mods & mask; return numlockState; }
/* gets vital info to switch xkb language groups */ static void get_group_info() { XkbDescRec *kbd_desc_ptr; XkbStateRec xkb_state; int i; ENTER; kbd_desc_ptr = XkbAllocKeyboard(); if (!kbd_desc_ptr) { ERR("can't alloc kbd info\n"); exit(1); } //kbd_desc_ptr->dpy = GDK_DISPLAY(); if (XkbGetControls(dpy, XkbAllControlsMask, kbd_desc_ptr) != Success) { ERR("can't get Xkb controls\n"); goto out; } ngroups = kbd_desc_ptr->ctrls->num_groups; if (ngroups < 1) { ERR("No keyboard group found\n"); goto out; } if (XkbGetState(dpy, XkbUseCoreKbd, &xkb_state) != Success) { ERR("can't get Xkb state\n"); goto out; } cur_group = xkb_state.group; DBG("cur_group = %d ngroups = %d\n", cur_group, ngroups); if (XkbGetNames(dpy, XkbGroupNamesMask, kbd_desc_ptr) != Success) { ERR("Can't get group names\n"); goto out; } for (i = 0; i < ngroups; i++) { if (!(group[i].name = XGetAtomName(dpy, kbd_desc_ptr->names->groups[i]))) { ERR("Can't get name of group #%d\n", i); goto out; } group[i].flag = default_flag; DBG("group[%d].name=%s\n", i, group[i].name); } get_group_flags(kbd_desc_ptr); out: XkbFreeKeyboard(kbd_desc_ptr, 0, True); }
/* =============== Sys_MapCharForKey =============== */ unsigned char Sys_MapCharForKey( int _key ) { int key; // scan key ( != doom key ) XkbStateRec kbd_state; XEvent event; KeySym keysym; int lookupRet; char buf[5]; if ( !have_xkb || !dpy ) { return (unsigned char)_key; } // query the current keyboard group, must be passed as bit 13-14 in the constructed XEvent // see X Keyboard Extension library specifications XkbGetState( dpy, XkbUseCoreKbd, &kbd_state ); // lookup scancode from doom key code. unique hits for ( key = 0; key < 128; key++ ) { if ( _key == s_scantokey[ key ] ) { break; } } if ( key == 128 ) { // it happens. these, we can't convert common->DPrintf( "Sys_MapCharForKey: doom key %d -> keycode failed\n", _key ); return (unsigned char)_key; } memset( &event, 0, sizeof( XEvent ) ); event.xkey.type = KeyPress; event.xkey.display = dpy; event.xkey.time = CurrentTime; event.xkey.keycode = key; event.xkey.state = kbd_state.group << 13; lookupRet = XLookupString( (XKeyEvent *)&event, buf, sizeof( buf ), &keysym, NULL ); if ( lookupRet <= 0 ) { Sys_Printf( "Sys_MapCharForKey: XLookupString key 0x%x failed\n", key ); return (unsigned char)_key; } if ( lookupRet > 1 ) { // only ever expecting 1 char.. Sys_Printf( "Sys_MapCharForKey: XLookupString returned '%s'\n", buf ); } return buf[ 0 ]; }
int xkb_toggle() { unsigned int mask; unsigned int numlockState; XkbStateRec xkbState; if( !xkb_init()) return 0; mask = xkb_numlock_mask(); if( mask == 0 ) return 0; XkbGetState( dpy, XkbUseCoreKbd, &xkbState); numlockState = xkbState.locked_mods & mask; if (numlockState) XkbLockModifiers ( dpy, XkbUseCoreKbd, mask, 0); else XkbLockModifiers ( dpy, XkbUseCoreKbd, mask, mask); return 1; }
SInt32 XWindowsKeyState::pollActiveGroup() const { // fixed condition where any group < -1 would have undetermined behaviour if (m_group >= 0) { return m_group; } #if HAVE_XKB_EXTENSION if (m_xkb != NULL) { XkbStateRec state; if (XkbGetState(m_display, XkbUseCoreKbd, &state) == Success) { return state.group; } } #endif return 0; }
char * getKeyboardLayout() { //Layout names are two char codes char activeLayout[3] = { '\0', '\0', '\0' }; // At the moment, my system will only switch between four layouts max char *layoutColors[4] = { colgreen, colred, colyellow, colblack }; // Grab name info XkbGetNames(dpy, XkbSymbolsNameMask, kbdDescPtr); // Get the actual symbol string, which looks like // pc+us+ru:2+fr:3+de:4+..... // where us, ru, fr, and de would be the available layouts, so we need to // copy the two-letter layout code that is currently active // Layout 0 is at 0+3 // Layout 1 is at 0+3+3 // Layout 2 is at 0+3+3+5 // Layout 3 is at 0+3+3+5+5 // Alloc layoutSymbols char *layoutSymbols = strdup(XGetAtomName(dpy, kbdDescPtr->names->symbols)); // Figure out which one is active and print it XkbStateRec xkbState; XkbGetState(dpy, XkbUseCoreKbd, &xkbState); int layoutOffset = xkbState.group*3 + 3; if(xkbState.group >= 2) { layoutOffset += (xkbState.group-1)*2; } // Copy the two-char code strncpy(activeLayout, &(layoutSymbols[layoutOffset]), 2); // print it //printf("%s\n", activeLayout); // clean up free(layoutSymbols); XkbFreeNames(kbdDescPtr, 0, True); return smprintf("%s[%s %s %s]", colcyan, layoutColors[(xkbState.group > 4 ? 4 : xkbState.group)], activeLayout, colcyan); }
static PyObject * virtkey_get_current_group_name(PyObject * self, PyObject * noargs) { PyObject * result = NULL; virtkey * cvirt = (virtkey *)self; Display * display = cvirt->display; /* get current group index */ XkbStateRec state; if (Success != XkbGetState(display, XkbUseCoreKbd, &state)) PyErr_SetString(virtkey_error, "XkbGetState failed"); else{ int group = state.locked_group; if (!XkbIsLegalGroup(group)) /* be defensive */ PyErr_SetString(virtkey_error, "invalid effective group"); else{ /* get group name */ if (!cvirt->kbd->names || !cvirt->kbd->names->groups) PyErr_SetString(virtkey_error, "no group names available"); else{ Atom atom = cvirt->kbd->names->groups[group]; if (atom != None){ char * group_name = XGetAtomName(display, atom); if (group_name){ result = PyString_FromString(group_name); XFree(group_name); } } } } } if (PyErr_Occurred()) return NULL; if (!result) Py_RETURN_NONE; return result; }
//returns QKeyEvent::key int KeyboardDevice::correctCode( QKeyEvent * k ) { // printf("---------------- correctCode( k->code = %d ) --------------------------- \n", k->key()); if (k->key() == 4100) return 13; if (k->key() == 4101) return 13; if (k->key() == 4099) return 8; if (k->key() == 4103) return 127; if (k->key() == 4097) return 9; if (k->key() == 4096) return 27; // puts("--------------------------11111111111111---------------------"); //----------------------!!!!!!!!!!!!!!!!!!------------------------ int group = 0; g_d = XOpenDisplay(NULL); if (g_d != NULL) { if ( XkbGetState( g_d, XkbUseCoreKbd, &state ) == Success ) group = state.locked_group; XCloseDisplay(g_d); } //----------------------!!!!!!!!!!!!!!!!!!------------------------ // printf("grpup = %d \n", group); if (group == 0) return k->key(); int res = -1; // printf("k->key = %d \n", k->key()); if (k->key() == 47) return 124; if (k->key() == 46) return 47; if (k->key() == 63) return 38; if (k->key() == 58) return 94; if (k->key() == 59) return 36; if (k->key() == 34) return 64; if (k->key() == 44) return 63; if (k->key() == 8470) return 35; if ( map_rus[ DefCodec->fromUnicode(k->text()) ]!= 0 ) { res = map_rus[ DefCodec->fromUnicode(k->text()) ]; return res; } return k->key(); }
PangoDirection _clutter_keymap_x11_get_direction (ClutterKeymapX11 *keymap) { g_return_val_if_fail (CLUTTER_IS_KEYMAP_X11 (keymap), PANGO_DIRECTION_NEUTRAL); #ifdef HAVE_XKB if (CLUTTER_BACKEND_X11 (keymap->backend)->use_xkb) { if (!keymap->has_direction) { Display *xdisplay = CLUTTER_BACKEND_X11 (keymap->backend)->xdpy; XkbStateRec state_rec; XkbGetState (xdisplay, XkbUseCoreKbd, &state_rec); update_direction (keymap, XkbStateGroup (&state_rec)); } return keymap->current_direction; } else #endif return PANGO_DIRECTION_NEUTRAL; }
static gboolean is_shift_pressed (void) { gboolean ret; GdkDisplay *display; XkbStateRec state; Bool status; ret = FALSE; display = gdk_display_get_default (); gdk_x11_display_error_trap_push (display); status = XkbGetState (GDK_DISPLAY_XDISPLAY (display), XkbUseCoreKbd, &state); gdk_x11_display_error_trap_pop_ignored (display); if (status == Success) { ret = state.mods & ShiftMask; } return ret; }
unsigned int X11Helper::getGroup() { XkbStateRec xkbState; XkbGetState( QX11Info::display(), XkbUseCoreKbd, &xkbState ); return xkbState.group; }
static void accessx_status_applet_update(AccessxStatusApplet* sapplet, AccessxStatusNotifyType notify_type, XkbEvent* event) { GdkWindow* window; gint i; window = gtk_widget_get_window(GTK_WIDGET(sapplet->applet)); if (notify_type & ACCESSX_STATUS_MODIFIERS) { unsigned int locked_mods = 0, latched_mods = 0; if (event != NULL) { locked_mods = event->state.locked_mods; latched_mods = event->state.latched_mods; } else if (sapplet->applet && window) { XkbStateRec state; XkbGetState(GDK_WINDOW_XDISPLAY(window), XkbUseCoreKbd, &state); locked_mods = state.locked_mods; latched_mods = state.latched_mods; } /* determine which modifiers are locked, and set state accordingly */ for (i = 0; i < G_N_ELEMENTS(modifiers); ++i) { if (modifiers[i].indicator != NULL && modifiers[i].mask) { if (locked_mods & modifiers[i].mask) { gtk_widget_set_sensitive(modifiers[i].indicator, TRUE); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_SELECTED, TRUE); #else gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_SELECTED); #endif } else if (latched_mods & modifiers[i].mask) { gtk_widget_set_sensitive(modifiers[i].indicator, TRUE); #if GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_state_flags (modifiers[i].indicator, GTK_STATE_FLAG_NORMAL, TRUE); #else gtk_widget_set_state(modifiers[i].indicator, GTK_STATE_NORMAL); #endif } else { gtk_widget_set_sensitive(modifiers[i].indicator, FALSE); } } } } if ((notify_type & ACCESSX_STATUS_SLOWKEYS) && (event != NULL)) { GdkPixbuf* pixbuf = accessx_status_applet_slowkeys_image(sapplet, &event->accessx); gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->slowfoo), pixbuf); g_object_unref(pixbuf); } if ((notify_type & ACCESSX_STATUS_BOUNCEKEYS) && (event != NULL)) { GdkPixbuf* pixbuf = accessx_status_applet_bouncekeys_image(sapplet, &event->accessx); gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->bouncefoo), pixbuf); g_object_unref(pixbuf); } if (notify_type & ACCESSX_STATUS_MOUSEKEYS) { GdkPixbuf* pixbuf = accessx_status_applet_mousekeys_image(sapplet, &event->state); gtk_image_set_from_pixbuf(GTK_IMAGE(sapplet->mousefoo), pixbuf); g_object_unref(pixbuf); } if (notify_type & ACCESSX_STATUS_ENABLED) { /* Update the visibility of widgets in the box */ /* XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask */ XkbGetControls(GDK_WINDOW_XDISPLAY(window), XkbAllControlsMask, sapplet->xkb); if (!(sapplet->xkb->ctrls->enabled_ctrls & (XkbMouseKeysMask | XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask))) { gtk_widget_show(sapplet->idlefoo); } else { gtk_widget_hide(sapplet->idlefoo); } if (sapplet->xkb->ctrls->enabled_ctrls & XkbMouseKeysMask) { gtk_widget_show(sapplet->mousefoo); } else { gtk_widget_hide(sapplet->mousefoo); } if (sapplet->xkb->ctrls->enabled_ctrls & XkbStickyKeysMask) { gtk_widget_show(sapplet->stickyfoo); } else { gtk_widget_hide(sapplet->stickyfoo); } if (sapplet->xkb->ctrls->enabled_ctrls & XkbSlowKeysMask) { gtk_widget_show(sapplet->slowfoo); } else { gtk_widget_hide(sapplet->slowfoo); } if (sapplet->xkb->ctrls->enabled_ctrls & XkbBounceKeysMask) { gtk_widget_show(sapplet->bouncefoo); } else { gtk_widget_hide(sapplet->bouncefoo); } } return; }
KeyboardEngine::KeyboardEngine(PARENT_TYPE *parent): PARENT_TYPE(parent), modifierItems(NUM_MODS) { // By default, ITEM_TYPE does not draw anything. If you subclass // ITEM_TYPE to create a visual item, you will need to uncomment the // following line and re-implement updatePaintNode() // setFlag(ItemHasContents, true); #ifndef USE_QT5 if (!singleton) singleton = this; else return; #endif KbdStateListener *statel; qDebug("Accessing X..."); modsState = QVector<char>(NUM_MODS); #ifdef USE_XCB conn = xcb_connect(0,0); statel = new KbdStateListener(conn); xcb_xkb_get_state_cookie_t ck = xcb_xkb_get_state_unchecked(conn, XCB_XKB_ID_USE_CORE_KBD); /* xcb_xkb_get_state_reply_t *status = xcb_xkb_get_state_reply(conn,ck,0); //return 0 with error code 10, whatever it means if (status->latchedMods & XCB_MOD_MASK_SHIFT) modsState[Shift] = Latched; else if (status->lockedMods & XCB_MOD_MASK_SHIFT) modsState[Shift] = Locked; else if (status->baseMods & XCB_MOD_MASK_SHIFT) modsState[Shift] = Effective; else modsState[Shift] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_CONTROL) modsState[Ctrl] = Latched; else if (status->lockedMods & XCB_MOD_MASK_CONTROL) modsState[Ctrl] = Locked; else if (status->baseMods & XCB_MOD_MASK_CONTROL) modsState[Ctrl] = Effective; else modsState[Ctrl] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_1) modsState[Alt] = Latched; else if (status->lockedMods & XCB_MOD_MASK_1) modsState[Alt] = Locked; else if (status->baseMods & XCB_MOD_MASK_1) modsState[Alt] = Effective; else modsState[Alt] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_2) modsState[NumLock] = Latched; else if (status->lockedMods & XCB_MOD_MASK_2) modsState[NumLock] = Locked; else if (status->baseMods & XCB_MOD_MASK_2) modsState[NumLock] = Effective; else modsState[NumLock] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_LOCK) modsState[CapsLock] = Latched; else if (status->lockedMods & XCB_MOD_MASK_LOCK) modsState[CapsLock] = Locked; else if (status->baseMods & XCB_MOD_MASK_LOCK) modsState[CapsLock] = Effective; else modsState[CapsLock] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_3) modsState[Meta] = Latched; else if (status->lockedMods & XCB_MOD_MASK_3) modsState[Meta] = Locked; else if (status->baseMods & XCB_MOD_MASK_3) modsState[Meta] = Effective; else modsState[AltGr] = Unsetted; if (status->latchedMods & XCB_MOD_MASK_5) modsState[AltGr] = Latched; else if (status->lockedMods & XCB_MOD_MASK_5) modsState[AltGr] = Locked; else if (status->baseMods & XCB_MOD_MASK_5) modsState[AltGr] = Effective; else modsState[AltGr] = Unsetted; delete status;*/ #else dpy = XOpenDisplay(0); statel = new KbdStateListener(dpy); XkbStatePtr status = new XkbStateRec; XkbGetState((Display *)dpy, XkbUseCoreKbd, status); if (status->latched_mods & ShiftMask) modsState[Shift] = Latched; else if (status->locked_mods & ShiftMask) modsState[Shift] = Locked; else if (status->base_mods & ShiftMask) modsState[Shift] = Effective; else modsState[Shift] = Unsetted; if (status->latched_mods & ControlMask) modsState[Ctrl] = Latched; else if (status->locked_mods & ControlMask) modsState[Ctrl] = Locked; else if (status->base_mods & ControlMask) modsState[Ctrl] = Effective; else modsState[Ctrl] = Unsetted; if (status->latched_mods & Mod1Mask) modsState[Alt] = Latched; else if (status->locked_mods & Mod1Mask) modsState[Alt] = Locked; else if (status->base_mods & Mod1Mask) modsState[Alt] = Effective; else modsState[Alt] = Unsetted; if (status->latched_mods & Mod2Mask) modsState[NumLock] = Latched; else if (status->locked_mods & Mod2Mask) modsState[NumLock] = Locked; else if (status->base_mods & Mod2Mask) modsState[NumLock] = Effective; else modsState[NumLock] = Unsetted; if (status->latched_mods & LockMask) modsState[CapsLock] = Latched; else if (status->locked_mods & LockMask) modsState[CapsLock] = Locked; else if (status->base_mods & LockMask) modsState[CapsLock] = Effective; else modsState[CapsLock] = Unsetted; if (status->latched_mods & Mod3Mask) modsState[Meta] = Latched; else if (status->locked_mods & Mod3Mask) modsState[Meta] = Locked; else if (status->base_mods & Mod3Mask) modsState[Meta] = Effective; else modsState[AltGr] = Unsetted; if (status->latched_mods & Mod5Mask) modsState[AltGr] = Latched; else if (status->locked_mods & Mod5Mask) modsState[AltGr] = Locked; else if (status->base_mods & Mod5Mask) modsState[AltGr] = Effective; else modsState[AltGr] = Unsetted; delete status; #endif qDebug("Accessing X done."); connect(statel, SIGNAL(eventRecived()), this, SLOT(modEventRecived())); statel->start(); qDebug("Looking for keysym layout symbols..."); QFileInfoList files = QDir("symbols").entryInfoList(QStringList("*.symbols"),QDir::Files); files += QDir("/usr/share/SandKeys/Symbols").entryInfoList(QStringList("*.symbols"),QDir::Files); foreach (QFileInfo fi, files) { qDebug() << "Found:" << fi.absoluteFilePath(); QFile f(fi.absoluteFilePath()); f.open(QFile::ReadOnly); while(!f.atEnd()){ #ifdef USE_QT5 QString l = f.readLine().trimmed(); #else QString l = QString::fromUtf8(f.readLine()).trimmed(); #endif if (l.startsWith('#')) continue; QStringList p = l.split(" ",QString::SkipEmptyParts); if (p.isEmpty()) continue; int keyid = p[0].toInt(); if (!keyid) continue; if (symbolMap.contains(keyid)) qDebug() << "WARNING: "<<keyid<<"have multiple definitions"; switch(p.length()){ case 0: continue; case 1: symbolMap.insert(keyid,""); break; case 2: symbolMap.insert(keyid,p[1]); break; case 3: p.pop_front(); symbolMap.insert(keyid,p.join(" ")); break; } } }
int XKeyboard::get_group() const { XkbStateRec xkbState; XkbGetState(_display, _deviceId, &xkbState); return static_cast<int>(xkbState.group); }
int main(int argc, char *argv[]) { Widget toplevel; XtAppContext app_con; Widget panel; Widget base[XkbNumModifiers]; Widget latched[XkbNumModifiers]; Widget locked[XkbNumModifiers]; Widget effective[XkbNumModifiers]; Widget compat[XkbNumModifiers]; Widget baseBox, latchBox, lockBox, effBox, compatBox; register int i; unsigned bit; XkbEvent ev; XkbStateRec state; static Arg hArgs[] = { {XtNorientation, (XtArgVal) XtorientHorizontal} }; static Arg vArgs[] = { {XtNorientation, (XtArgVal) XtorientVertical} }; static Arg onArgs[] = { {XtNon, (XtArgVal) True} }; static Arg offArgs[] = { {XtNon, (XtArgVal) False} }; static char *fallback_resources[] = { "*Box*background: grey50", "*Box*borderWidth: 0", "*Box*vSpace: 1", NULL }; for (i = 1; i < argc; i++) { if (strcmp(argv[i], "-version") == 0) { printf("xkbwatch (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION); exit(0); } } uSetErrorFile(NullString); toplevel = XtOpenApplication(&app_con, "XkbWatch", options, XtNumber(options), &argc, argv, fallback_resources, sessionShellWidgetClass, NULL, ZERO); if (toplevel == NULL) { uFatalError("Couldn't create application top level\n"); exit(1); } inDpy = outDpy = XtDisplay(toplevel); if (inDpy) { int i1, mn, mj; mj = XkbMajorVersion; mn = XkbMinorVersion; if (!XkbQueryExtension(inDpy, &i1, &evBase, &errBase, &mj, &mn)) { uFatalError("Server doesn't support a compatible XKB\n"); exit(1); } } panel = XtCreateManagedWidget("xkbwatch", boxWidgetClass, toplevel, vArgs, 1); if (panel == NULL) { uFatalError("Couldn't create top level box\n"); exit(1); } baseBox = XtCreateManagedWidget("base", boxWidgetClass, panel, hArgs, 1); if (baseBox == NULL) uFatalError("Couldn't create base modifiers box\n"); latchBox = XtCreateManagedWidget("latched", boxWidgetClass, panel, hArgs, 1); if (latchBox == NULL) uFatalError("Couldn't create latched modifiers box\n"); lockBox = XtCreateManagedWidget("locked", boxWidgetClass, panel, hArgs, 1); if (lockBox == NULL) uFatalError("Couldn't create locked modifiers box\n"); effBox = XtCreateManagedWidget("effective", boxWidgetClass, panel, hArgs, 1); if (effBox == NULL) uFatalError("Couldn't create effective modifiers box\n"); compatBox = XtCreateManagedWidget("compat", boxWidgetClass, panel, hArgs, 1); if (compatBox == NULL) uFatalError("Couldn't create compatibility state box\n"); XkbSelectEvents(inDpy, XkbUseCoreKbd, XkbStateNotifyMask, XkbStateNotifyMask); XkbGetState(inDpy, XkbUseCoreKbd, &state); for (i = XkbNumModifiers - 1, bit = 0x80; i >= 0; i--, bit >>= 1) { ArgList list; char buf[30]; sprintf(buf, "base%d", i); if (state.base_mods & bit) list = onArgs; else list = offArgs; base[i] = XtCreateManagedWidget(buf, ledWidgetClass, baseBox, list, 1); sprintf(buf, "latched%d", i); if (state.latched_mods & bit) list = onArgs; else list = offArgs; latched[i] = XtCreateManagedWidget(buf, ledWidgetClass, latchBox, list, 1); sprintf(buf, "locked%d", i); if (state.locked_mods & bit) list = onArgs; else list = offArgs; locked[i] = XtCreateManagedWidget(buf, ledWidgetClass, lockBox, list, 1); sprintf(buf, "effective%d", i); if (state.mods & bit) list = onArgs; else list = offArgs; effective[i] = XtCreateManagedWidget(buf, ledWidgetClass, effBox, list, 1); sprintf(buf, "compat%d", i); if (state.compat_state & bit) list = onArgs; else list = offArgs; compat[i] = XtCreateManagedWidget(buf, ledWidgetClass, compatBox, list, 1); } XtRealizeWidget(toplevel); while (1) { XtAppNextEvent(app_con, &ev.core); if (ev.core.type == evBase + XkbEventCode) { if (ev.any.xkb_type == XkbStateNotify) { unsigned changed; if (ev.state.changed & XkbModifierBaseMask) { changed = ev.state.base_mods ^ state.base_mods; state.base_mods = ev.state.base_mods; for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) { if (changed & bit) { ArgList list; if (state.base_mods & bit) list = onArgs; else list = offArgs; XtSetValues(base[i], list, 1); } } } if (ev.state.changed & XkbModifierLatchMask) { changed = ev.state.latched_mods ^ state.latched_mods; state.latched_mods = ev.state.latched_mods; for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) { if (changed & bit) { ArgList list; if (state.latched_mods & bit) list = onArgs; else list = offArgs; XtSetValues(latched[i], list, 1); } } } if (ev.state.changed & XkbModifierLockMask) { changed = ev.state.locked_mods ^ state.locked_mods; state.locked_mods = ev.state.locked_mods; for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) { if (changed & bit) { ArgList list; if (state.locked_mods & bit) list = onArgs; else list = offArgs; XtSetValues(locked[i], list, 1); } } } if (ev.state.changed & XkbModifierStateMask) { changed = ev.state.mods ^ state.mods; state.mods = ev.state.mods; for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) { if (changed & bit) { ArgList list; if (state.mods & bit) list = onArgs; else list = offArgs; XtSetValues(effective[i], list, 1); } } } if (ev.state.changed & XkbCompatStateMask) { changed = ev.state.compat_state ^ state.compat_state; state.compat_state = ev.state.compat_state; for (i = 0, bit = 1; i < XkbNumModifiers; i++, bit <<= 1) { if (changed & bit) { ArgList list; if (state.compat_state & bit) list = onArgs; else list = offArgs; XtSetValues(compat[i], list, 1); } } } } } else XtDispatchEvent(&ev.core); } /* BAIL: */ if (inDpy) XCloseDisplay(inDpy); if (outDpy != inDpy) XCloseDisplay(outDpy); inDpy = outDpy = NULL; return 0; }
void XWindow::OnKeyPress(WindowEventKey *e) { // ******************************************************************** // Calculate keySym and keyText 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 : ""; // ******************************************************************** // Manage KeyPreview and KeyPress events ControlEventKey ek(*e, KeyCompositionSymbol(keySym, keyText)); // Key preview to every control for (int i=0; i<controls->Count(); i++) (*controls)[i]->OnKeyPreview(&ek); // OnKeyPress until the focused control catches it bool redirected = false; for (int i=0; i<controls->Count() && !redirected; i++) redirected = (*controls)[i]->OnKeyPress(&ek); // Noone catched the event? if (!redirected) { if (keySym == KeySymbols::Tab) { // Window focus rotate if (!e->PressedShift()) ControlFocusNext(); else ControlFocusPrevious(); } else if (keySym == KeySymbols::Return) { // Return: Window Accept } else if (keySym == KeySymbols::Escape) { // Escape: Window Cancel } else if (keySym == KeySymbols::Space) { // Return: Window Accept } } DelegationOnKeyPress().Execute(e); // ******************************************************************** // Manage KeySymbol event bool continueComposing = false; Text t = KeyCompositionManager::Default().GetComposedKeySym(*composeKeySymBuffer + keyText, continueComposing); *composeKeySymBuffer = continueComposing ? *composeKeySymBuffer + keyText : ""; // Send Key Symbol Event if (!continueComposing) { KeyCompositionSymbol symbol(t == keyText ? keySym : 0, t); WindowEventKeySymbol weks(symbol); OnKeySymbol(&weks); } }