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);
}
}
