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