// 0 - Success int xkbleds_init() { KeyCode keys[NUM_LEDS]; XkbDescPtr xkb; char *ind_name = NULL; int j, mask; int idx[NUM_LEDS];/* NUM, CAPS, SCROLL: indicator index, for XKB */ // open X display d = XOpenDisplay(NULL); if (!d) return 1; // get keycodes for(i = 0; i < NUM_LEDS; i++) keys[i] = XKeysymToKeycode(d, key_syms[i]); // get the keyboard xkb = XkbAllocKeyboard(); if(!xkb){ XCloseDisplay(d); return 1; } if(XkbGetNames(d, XkbIndicatorNamesMask, xkb) != Success){ XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 1; } // get masks and indexes of indicators for(i = 0; i < XkbNumIndicators; i++) { if(xkb->names->indicators[i]) ind_name = XGetAtomName(d, xkb->names->indicators[i]); for(j = 0; j < NUM_LEDS; j++){ if(ind_name && !strcmp(lock_names[j], ind_name)){ if(XkbGetNamedIndicator(d, xkb->names->indicators[i], &mask, NULL, NULL, NULL) == True){ masks[j] = 1 << mask; idx[j] = mask; } else { XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 1; } } } if(ind_name){ free(ind_name); ind_name = NULL; } } // cleanup XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 0; }
//Need to handle errors here properly. void getKbd(virtkey * cvirt){ if (cvirt->kbd) XkbFreeKeyboard (cvirt->kbd, XkbAllComponentsMask, True); cvirt->kbd = XkbGetKeyboard (cvirt->display, XkbCompatMapMask | XkbNamesMask | XkbGeometryMask, XkbUseCoreKbd); #if 0 /* test missing keyboard (LP: 526791) keyboard on/off every 10 seconds */ if (getenv ("VIRTKEY_DEBUG")) { if (cvirt->kbd && time(NULL) % 20 < 10) { XkbFreeKeyboard (cvirt->kbd, XkbAllComponentsMask, True); cvirt->kbd = NULL; } } #endif if (cvirt->kbd == NULL){ PyErr_SetString(virtkey_error, "XkbGetKeyboard failed to get keyboard from x server"); return; } /* Status stat = XkbGetGeometry (cvirt->display, cvirt->kbd); if (stat == BadValue) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Value.\n"); if (stat == BadImplementation) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Implementation.\n"); if (stat == BadName) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Name.\n"); if (stat == BadAlloc) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Alloc.\n"); */ if (XkbGetNames (cvirt->display, XkbAllNamesMask, cvirt->kbd) != Success) PyErr_SetString(virtkey_error, "Error getting key name info.\n"); return; }
static int check_for_evdev(void) { SDL_SysWMinfo info; XkbDescPtr desc = NULL; int has_evdev = 0; char *keycodes = NULL; SDL_VERSION(&info.version); if (!SDL_GetWMInfo(&info)) { return 0; } desc = XkbGetKeyboard(info.info.x11.display, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (desc && desc->names) { keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes); if (keycodes == NULL) { fprintf(stderr, "could not lookup keycode name\n"); } else if (strstart(keycodes, "evdev", NULL)) { has_evdev = 1; } else if (!strstart(keycodes, "xfree86", NULL)) { fprintf(stderr, "unknown keycodes `%s', please report to " "[email protected]\n", keycodes); } } if (desc) { XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True); } if (keycodes) { XFree(keycodes); } return has_evdev; }
VkBool32 VKTS_APIENTRY _visualInitKey(Display* display) { memset(g_keys, VKTS_KEY_UNKNOWN, sizeof(g_keys)); XkbDescPtr desc = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd); if (!desc) { return VK_FALSE; } char name[XkbKeyNameLength + 1]; name[XkbKeyNameLength] = '\0'; for (int32_t keyCode = desc->min_key_code; keyCode <= desc->max_key_code; keyCode++) { if (keyCode < 0 || keyCode >= 512) { continue; } memcpy(name, desc->names->keys[keyCode].name, XkbKeyNameLength); g_keys[keyCode] = _visualMapKey(name); } XkbFreeKeyboard(desc, 0, True); return VK_TRUE; }
void CLowLevelKeyboard::Initialize(HWND hWnd) { SDL_EnableUNICODE(1); // set repeat to 10ms to ensure repeat time < frame time // so that hold times can be reliably detected SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, 10); #if defined(_LINUX) && !defined(__APPLE__) Display* dpy = XOpenDisplay(NULL); if (!dpy) return; XkbDescPtr desc; char* symbols; desc = XkbGetKeyboard(dpy, XkbAllComponentsMask, XkbUseCoreKbd); if(!desc) { XCloseDisplay(dpy); return; } symbols = XGetAtomName(dpy, desc->names->symbols); if(symbols) { CLog::Log(LOGDEBUG, "CLowLevelKeyboard::Initialize - XKb symbols %s", symbols); if(strstr(symbols, "(evdev)")) m_bEvdev = true; } XFree(symbols); XkbFreeKeyboard(desc, XkbAllComponentsMask, True); XCloseDisplay(dpy); #endif }
void KeyboardLayoutWidget::setKeyboard(XkbComponentNamesPtr names) { release(); if (xkb) XkbFreeKeyboard(xkb, 0, TRUE); if (names) { xkb = XkbGetKeyboardByName (QX11Info::display(), XkbUseCoreKbd, names, 0, XkbGBN_GeometryMask | XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask | XkbGBN_ClientSymbolsMask | XkbGBN_IndicatorMapMask, FALSE); xkbOnDisplay = FALSE; } else { xkb = XkbGetKeyboard (QX11Info::display(), XkbGBN_GeometryMask | XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask | XkbGBN_SymbolsMask | XkbGBN_IndicatorMapMask, XkbUseCoreKbd); XkbGetNames (QX11Info::display(), XkbAllNamesMask, xkb); xkbOnDisplay = TRUE; } if (xkb == NULL) return; alloc (); init(); initColors(); generatePixmap(true); repaint(); }
XkbDescPtr XkbCompileKeymap(DeviceIntPtr dev, XkbRMLVOSet *rmlvo) { XkbComponentNamesRec kccgst; XkbRF_VarDefsRec mlvo; XkbDescPtr xkb; char name[PATH_MAX]; if (!dev || !rmlvo) { LogMessage(X_ERROR, "XKB: No device or RMLVO specified\n"); return NULL; } mlvo.model = rmlvo->model; mlvo.layout = rmlvo->layout; mlvo.variant = rmlvo->variant; mlvo.options = rmlvo->options; /* XDNFR already logs for us. */ if (!XkbDDXNamesFromRules(dev, rmlvo->rules, &mlvo, &kccgst)) return NULL; /* XDLKBN too, but it might return 0 as well as allocating. */ if (!XkbDDXLoadKeymapByNames(dev, &kccgst, XkmAllIndicesMask, 0, &xkb, name, PATH_MAX)) { if (xkb) XkbFreeKeyboard(xkb, 0, TRUE); return NULL; } return xkb; }
XKeyboard::~XKeyboard() { if(_kbdDescPtr!=NULL) XkbFreeKeyboard(_kbdDescPtr, 0, True); XCloseDisplay(_display); }
XkbDescPtr XkbCompileKeymapFromString(DeviceIntPtr dev, const char *keymap, int keymap_length) { XkbDescPtr xkb; unsigned int need, provided; if (!dev || !keymap) { LogMessage(X_ERROR, "XKB: No device or keymap specified\n"); return NULL; } /* These are the components we really really need */ need = XkmSymbolsMask | XkmCompatMapMask | XkmTypesMask | XkmKeyNamesMask | XkmVirtualModsMask; provided = XkbDDXLoadKeymapFromString(dev, keymap, keymap_length, XkmAllIndicesMask, need, &xkb); if ((need & provided) != need) { if (xkb) { XkbFreeKeyboard(xkb, 0, TRUE); xkb = NULL; } } return KeymapOrDefaults(dev, xkb); }
static void upload_xkb_description (Display *xdisplay, const gchar *rules_file_path, XkbRF_VarDefsRec *var_defs, XkbComponentNamesRec *comp_names) { XkbDescRec *xkb_desc; gchar *rules_file; /* Upload it to the X server using the same method as setxkbmap */ xkb_desc = XkbGetKeyboardByName (xdisplay, XkbUseCoreKbd, comp_names, XkbGBN_AllComponentsMask, XkbGBN_AllComponentsMask & (~XkbGBN_GeometryMask), True); if (!xkb_desc) { g_warning ("Couldn't upload new XKB keyboard description"); return; } XkbFreeKeyboard (xkb_desc, 0, True); rules_file = g_path_get_basename (rules_file_path); if (!XkbRF_SetNamesProp (xdisplay, rules_file, var_defs)) g_warning ("Couldn't update the XKB root window property"); g_free (rules_file); }
void xkblayoutCleanup() { XkbFreeKeyboard(kbdDescPtr, 0, True); XCloseDisplay(dpy); }
XWindowsKeyState::~XWindowsKeyState() { #if HAVE_XKB_EXTENSION if (m_xkb != NULL) { XkbFreeKeyboard(m_xkb, 0, True); } #endif }
void bst_xkb_close (void) { g_return_if_fail (bst_xkb_display != NULL); XkbFreeKeyboard (bst_xkb_desc, XkbAllComponentsMask, True); bst_xkb_desc = NULL; XCloseDisplay (bst_xkb_display); bst_xkb_display = NULL; }
/* * Loads the XKB keymap from the X11 server and feeds it to xkbcommon. * Necessary so that we can properly let xkbcommon track the keyboard state and * translate keypresses to utf-8. * * Ideally, xkbcommon would ship something like this itself, but as of now * (version 0.2.0), it doesn’t. * */ static bool load_keymap(void) { bool ret = false; XkbFileInfo result; memset(&result, '\0', sizeof(result)); result.xkb = XkbGetKeyboard(display, XkbAllMapComponentsMask, XkbUseCoreKbd); if (result.xkb == NULL) { fprintf(stderr, "[i3lock] XKB: XkbGetKeyboard failed\n"); return false; } FILE *temp = tmpfile(); if (temp == NULL) { fprintf(stderr, "[i3lock] could not create tempfile\n"); return false; } bool ok = XkbWriteXKBKeymap(temp, &result, false, false, NULL, NULL); if (!ok) { fprintf(stderr, "[i3lock] XkbWriteXKBKeymap failed\n"); goto out; } rewind(temp); if (xkb_context == NULL) { if ((xkb_context = xkb_context_new(0)) == NULL) { fprintf(stderr, "[i3lock] could not create xkbcommon context\n"); goto out; } } if (xkb_keymap != NULL) xkb_keymap_unref(xkb_keymap); if ((xkb_keymap = xkb_keymap_new_from_file(xkb_context, temp, XKB_KEYMAP_FORMAT_TEXT_V1, 0)) == NULL) { fprintf(stderr, "[i3lock] xkb_keymap_new_from_file failed\n"); goto out; } struct xkb_state *new_state = xkb_state_new(xkb_keymap); if (new_state == NULL) { fprintf(stderr, "[i3lock] xkb_state_new failed\n"); goto out; } if (xkb_state != NULL) xkb_state_unref(xkb_state); xkb_state = new_state; ret = true; out: XkbFreeKeyboard(result.xkb, XkbAllComponentsMask, true); fclose(temp); return ret; }
static void virtkey_dealloc(PyObject * self){ virtkey * cvirt = (virtkey *)self; if (cvirt->kbd) XkbFreeKeyboard (cvirt->kbd, XkbAllComponentsMask, True); if (cvirt->keysyms) XFree(cvirt->keysyms); if (cvirt->display) XCloseDisplay(cvirt->display); Py_TYPE(self)->tp_free((PyObject*)self); }
unsigned int xkb_numlock_mask() { XkbDescPtr xkb; if(( xkb = XkbGetKeyboard( qt_xdisplay(), XkbAllComponentsMask, XkbUseCoreKbd )) != NULL ) { unsigned int mask = xkb_mask_modifier( xkb, "NumLock" ); XkbFreeKeyboard( xkb, 0, True ); return mask; } return 0; }
static unsigned int xkb_numlock_mask(Display* dpy) { XkbDescPtr xkb; xkb = XkbGetKeyboard( dpy, XkbAllComponentsMask, XkbUseCoreKbd ); if( xkb != nullptr ) { unsigned int mask = xkb_mask_modifier( xkb, "NumLock" ); XkbFreeKeyboard( xkb, 0, True ); return mask; } return 0; }
int freerdp_keyboard_load_map_from_xkbfile(void* display, RDP_SCANCODE x11_keycode_to_rdp_scancode[256]) { int i, j; boolean found; XkbDescPtr xkb; boolean status = false; if (display && (xkb = XkbGetMap(display, 0, XkbUseCoreKbd))) { if (XkbGetNames(display, XkbKeyNamesMask, xkb) == Success) { char xkb_keyname[5] = { 42, 42, 42, 42, 0 }; /* end-of-string at index 5 */ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { found = false; memcpy(xkb_keyname, xkb->names->keys[i].name, 4); if (strlen(xkb_keyname) < 1) continue; for (j = 0; j < ARRAY_SIZE(XKB_KEY_NAME_SCANCODE_TABLE); j++) { if (!strcmp(xkb_keyname, XKB_KEY_NAME_SCANCODE_TABLE[j].xkb_keyname)) { DEBUG_KBD("%4s: keycode: 0x%02X -> rdp scancode: 0x%04X", xkb_keyname, i, XKB_KEY_NAME_SCANCODE_TABLE[j].rdp_scancode); if (found) { DEBUG_KBD("Internal error! duplicate key %s!", xkb_keyname); } x11_keycode_to_rdp_scancode[i] = XKB_KEY_NAME_SCANCODE_TABLE[j].rdp_scancode; found = true; } } if (!found) { DEBUG_KBD("%4s: keycode: 0x%02X -> no RDP scancode found", xkb_keyname, i); } } status = true; } XkbFreeKeyboard(xkb, 0, 1); } return status; }
// Called once. Checks whether evdev is loaded and sets m_bEvdev accordingly. static void InitEvdev(void) { /* 歌方: 1、 卦指: 1、 傍苧: 1、 */ // Set m_bEvdevInit to indicate we have been initialised m_bEvdevInit = true; Display* dpy = XOpenDisplay(NULL); if (!dpy) { CLog::Log(LOGERROR, "CWinEventsSDL::CWinEventsSDL - XOpenDisplay failed"); return; } XkbDescPtr desc; char* symbols; desc = XkbGetKeyboard(dpy, XkbAllComponentsMask, XkbUseCoreKbd); if(!desc) { XCloseDisplay(dpy); CLog::Log(LOGERROR, "CWinEventsSDL::CWinEventsSDL - XkbGetKeyboard failed"); return; } symbols = XGetAtomName(dpy, desc->names->symbols); if(symbols) { CLog::Log(LOGDEBUG, "CWinEventsSDL::CWinEventsSDL - XKb symbols %s", symbols); if(strstr(symbols, "(evdev)")) m_bEvdev = true; else m_bEvdev = false; } XFree(symbols); XkbFreeKeyboard(desc, XkbAllComponentsMask, True); XCloseDisplay(dpy); CLog::Log(LOGDEBUG, "CWinEventsSDL::CWinEventsSDL - m_bEvdev = %d", m_bEvdev); }
void AutoTypePlatformX11::unload() { // Restore the KeyboardMapping to its original state. AddKeysym(NoSymbol); if (m_keysymTable) { XFree(m_keysymTable); } if (m_xkb) { XkbFreeKeyboard(m_xkb, XkbAllComponentsMask, True); } m_loaded = false; }
/* --- functions --- */ gboolean bst_xkb_open (const gchar *const_display, gboolean sync) { gchar *display = (gchar*) const_display; int ext_base_event, ext_base_error, ext_status; int ext_major = XkbMajorVersion; int ext_minor = XkbMinorVersion; g_return_val_if_fail (display != NULL, FALSE); g_return_val_if_fail (bst_xkb_display == NULL, FALSE); bst_xkb_display = XkbOpenDisplay (display, &ext_base_event, &ext_base_error, &ext_major, &ext_minor, &ext_status); /* possible values for ext_status: * XkbOD_BadLibraryVersion library version mismatch * XkbOD_ConnectionRefused unable to open display * XkbOD_BadServerVersion server version mismatch * XkbOD_NonXkbServer XKB extension not present * XkbOD_Success guess what */ if (bst_xkb_display && sync) XSynchronize (bst_xkb_display, True); if (bst_xkb_display && ext_status == XkbOD_Success) { bst_xkb_desc = XkbGetKeyboard (bst_xkb_display, XkbAllComponentsMask, XkbUseCoreKbd); if (bst_xkb_desc && (!bst_xkb_desc->names || !bst_xkb_desc->geom)) { XkbFreeKeyboard (bst_xkb_desc, XkbAllComponentsMask, True); bst_xkb_desc = NULL; } } if (bst_xkb_display && !bst_xkb_desc) { XCloseDisplay (bst_xkb_display); bst_xkb_display = NULL; } return bst_xkb_desc != NULL; }
/* 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); }
Bool NestedClientGetKeyboardMappings(NestedClientPrivatePtr pPriv, KeySymsPtr keySyms, CARD8 *modmap, XkbControlsPtr ctrls) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; int i, j; XkbDescPtr xkb; XDisplayKeycodes(pPriv->display, &min_keycode, &max_keycode); keymap = XGetKeyboardMapping(pPriv->display, min_keycode, max_keycode - min_keycode + 1, &mapWidth); memset(modmap, 0, sizeof(CARD8) * MAP_LENGTH); modifier_keymap = XGetModifierMapping(pPriv->display); for (j = 0; j < 8; j++) for(i = 0; i < modifier_keymap->max_keypermod; i++) { CARD8 keycode; if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap->max_keypermod + i])) modmap[keycode] |= 1<<j; } XFreeModifiermap(modifier_keymap); keySyms->minKeyCode = min_keycode; keySyms->maxKeyCode = max_keycode; keySyms->mapWidth = mapWidth; keySyms->map = keymap; xkb = XkbGetKeyboard(pPriv->display, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { xf86DrvMsg(pPriv->scrnIndex, X_ERROR, "Couldn't get XKB keyboard.\n"); free(keymap); return FALSE; } if(XkbGetControls(pPriv->display, XkbAllControlsMask, xkb) != Success) { xf86DrvMsg(pPriv->scrnIndex, X_ERROR, "Couldn't get XKB keyboard controls.\n"); free(keymap); return FALSE; } memcpy(ctrls, xkb->ctrls, sizeof(XkbControlsRec)); XkbFreeKeyboard(xkb, 0, False); return TRUE; }
static void accessx_status_applet_destroy(GtkWidget* widget, gpointer user_data) { AccessxStatusApplet* sapplet = user_data; /* do we need to free the icon factory ? */ gdk_window_remove_filter(NULL, accessx_status_xkb_filter, sapplet); if (sapplet->xkb) { XkbFreeKeyboard(sapplet->xkb, 0, True); } if (sapplet->xkb_display) { XCloseDisplay(sapplet->xkb_display); } }
int init_keycodes_from_xkb(void *dpy, RdpKeycodes x_keycode_to_rdp_keycode) { int ret = 0; XkbDescPtr xkb; if (dpy && (xkb = XkbGetMap(dpy, 0, XkbUseCoreKbd))) { if (XkbGetNames(dpy, XkbKeyNamesMask, xkb) == Success) { char buf[5] = {42, 42, 42, 42, 0}; /* end-of-string at pos 5 */ int i, j; memset(x_keycode_to_rdp_keycode, 0, sizeof(x_keycode_to_rdp_keycode)); for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { memcpy(buf, xkb->names->keys[i].name, 4); /* TODO: Use more efficient search ... but it is so fast that it doesn't matter */ j = sizeof(virtualKeyboard) / sizeof(virtualKeyboard[0]) - 1; while (j >= 0) { if (virtualKeyboard[j].x_keyname && !strcmp(buf, virtualKeyboard[j].x_keyname)) break; j--; } if (j >= 0) { DEBUG_KBD("X key code %3d has keyname %-4s -> RDP keycode %d/%d", i, buf, virtualKeyboard[j].extended, virtualKeyboard[j].scancode); x_keycode_to_rdp_keycode[i].extended = virtualKeyboard[j].extended; x_keycode_to_rdp_keycode[i].keycode = virtualKeyboard[j].scancode; #ifdef WITH_DEBUG_KBD x_keycode_to_rdp_keycode[i].keyname = virtualKeyboard[j].x_keyname; #endif } else DEBUG_KBD("X key code %3d has keyname %-4s -> ??? - not found", i, buf); } ret = 1; } XkbFreeKeyboard(xkb, 0, 1); } return ret; }
void XkbDeleteRulesDflts(void) { free(XkbRulesDflt); XkbRulesDflt = NULL; free(XkbModelDflt); XkbModelDflt = NULL; free(XkbLayoutDflt); XkbLayoutDflt = NULL; free(XkbVariantDflt); XkbVariantDflt = NULL; free(XkbOptionsDflt); XkbOptionsDflt = NULL; XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE); xkb_cached_map = NULL; }
static void clutter_keymap_x11_finalize (GObject *gobject) { ClutterKeymapX11 *keymap; ClutterEventTranslator *translator; keymap = CLUTTER_KEYMAP_X11 (gobject); translator = CLUTTER_EVENT_TRANSLATOR (keymap); #ifdef HAVE_XKB _clutter_backend_remove_event_translator (keymap->backend, translator); if (keymap->xkb_desc != NULL) XkbFreeKeyboard (keymap->xkb_desc, XkbAllComponentsMask, True); #endif G_OBJECT_CLASS (clutter_keymap_x11_parent_class)->finalize (gobject); }
static void set_repeatrate(int delay, double rate) { if( !X11Helper::xkbSupported(NULL) ) { kError() << "Failed to set keyboard repeat rate: xkb is not supported"; return; } XkbDescPtr xkb = XkbAllocKeyboard(); if (xkb) { Display* dpy = QX11Info::display(); int res = XkbGetControls(dpy, XkbRepeatKeysMask, xkb); xkb->ctrls->repeat_delay = delay; xkb->ctrls->repeat_interval = (int)floor(1000/rate + 0.5); res = XkbSetControls(dpy, XkbRepeatKeysMask, xkb); XkbFreeKeyboard(xkb, 0, true); return; } }
static unsigned int numlock_mask(Display* dpy) { XkbDescPtr xkb = XkbGetKeyboard(dpy, XkbAllComponentsMask, XkbUseCoreKbd); if(xkb == NULL) return 0; char* modstr; unsigned int mask = 0; for(int i = 0; i < XkbNumVirtualMods; i++) { modstr = XGetAtomName(xkb->dpy, xkb->names->vmods[i]); if(modstr != NULL && strcmp(modstr, "NumLock") == 0) { XkbVirtualModsToReal(xkb, 1 << i, &mask); break; } } XkbFreeKeyboard(xkb, 0, True); return mask; }
void _XkbReloadDpy(Display *dpy) { XkbInfoPtr xkbi; XkbDescRec *desc; unsigned oldDeviceID; if (_XkbUnavailable(dpy)) return; xkbi = dpy->xkb_info; LockDisplay(dpy); if (xkbi->desc) { oldDeviceID= xkbi->desc->device_spec; XkbFreeKeyboard(xkbi->desc,XkbAllComponentsMask,True); xkbi->desc= NULL; xkbi->flags&= ~(XkbMapPending|XkbXlibNewKeyboard); xkbi->changes.changed= 0; } else oldDeviceID= XkbUseCoreKbd; UnlockDisplay(dpy); desc = XkbGetMap(dpy,XkbAllClientInfoMask,XkbUseCoreKbd); if (!desc) return; LockDisplay(dpy); xkbi->desc = desc; UnlockDisplay(dpy); if (desc->device_spec!=oldDeviceID) { /* transfer(?) event masks here */ #ifdef NOTYET unsigned oldEvents; oldEvents= xkbi->selected_events; XkbSelectEventDetails(dpy,xkbi->desc->device_spec,XkbMapNotify, XkbAllMapComponentsMask,XkbAllClientInfoMask); LockDisplay(dpy); xkbi->selected_events= oldEvents; UnlockDisplay(dpy); #endif } return; }