kbrate* xkbset_repeatrate(Display *dpy, int delay, int interval) { kbrate* kb_bak = malloc(sizeof(kbrate)); XkbDescPtr xkb = XkbAllocKeyboard(); if (!xkb){return;} XkbGetControls(dpy, XkbRepeatKeysMask, xkb); kb_bak->delay = xkb->ctrls->repeat_delay; kb_bak->interval = xkb->ctrls->repeat_interval; xkb->ctrls->repeat_delay = delay; xkb->ctrls->repeat_interval = interval; XkbSetControls(dpy, XkbRepeatKeysMask, xkb); // Need to call GetControls again to reload into the server? XkbGetControls(dpy, XkbRepeatKeysMask, xkb); return kb_bak; }
static unsigned int xkb_get_bouncekeys_delay (SpiDEController *controller) { unsigned int retval = 0; DEControllerPrivateData *priv = controller->priv; #ifdef HAVE_XKB #ifdef XKB_HAS_GET_BOUNCE_KEYS_DELAY retval = XkbGetBounceKeysDelay (spi_get_display (), XkbUseCoreKbd, &bounce_delay); #else if (!(priv->xkb_desc == (XkbDescPtr) BadAlloc || priv->xkb_desc == NULL)) { Status s = XkbGetControls (spi_get_display (), XkbAllControlsMask, priv->xkb_desc); if (s == Success) { if (priv->xkb_desc->ctrls->enabled_ctrls & XkbBounceKeysMask) retval = priv->xkb_desc->ctrls->debounce_delay; } } #endif #endif #ifdef SPI_XKB_DEBUG fprintf (stderr, "BounceKeys delay: %d\n", (int) retval); #endif return retval; }
/* 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); }
//======================================== // XAccess... //---------------------------------------- void XAccess(Display *dpy,char *displayname) { #ifndef __powerpc__ XkbDescPtr xkb; int major, minor,op, event, error; int timeout = 5; // Query XKB Extension... // ----------------------- major = XkbMajorVersion; minor = XkbMinorVersion; if (XkbQueryExtension(dpy, &op, &event, &error, &major, &minor) == 0) { printf("xaccess: Unable to initialize XKEYBOARD extension"); exit(1); } while (timeout > 0) { xkb = XkbGetKeyboard(dpy, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { timeout -= 1; sleep(1); } else { break; } } if (timeout <= 0) { printf("xaccess: Couldn't get keyboard\n"); exit(1); } // Everything is fine, now set the access block... // ------------------------------------------------ XkbGetControls(dpy, XkbAllControlsMask, xkb); if (xkb->ctrls == NULL) { xkb->ctrls = (XkbControlsPtr)malloc(sizeof(XkbControlsRec)); } xkb->ctrls->enabled_ctrls |= XkbMouseKeysMask | XkbMouseKeysAccelMask; xkb->ctrls->mk_delay = 40; xkb->ctrls->mk_interval = 10; xkb->ctrls->mk_time_to_max = 1000; xkb->ctrls->mk_max_speed = 500; xkb->ctrls->mk_curve = 0; // Set keyboard control... // ------------------------ XkbSetControls(dpy, XkbAllControlsMask, xkb); XSync(dpy, False); #endif }
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; }
//===================================== // XAccessX slotIntro... //------------------------------------- void XAccessX::slotIntro (int index) { if (index == mIndex) { XWrapPointer< QDict<char> > mText (mTextPtr); XTextBrowser* info; QString message; QString idents; bool active = FALSE; info = mIntro -> getTextView(); message = mText["accessx_header"]; XkbGetControls(x11Display(), XkbAllControlsMask, xkb); if (xkb->ctrls == NULL) { active = FALSE; } else { if (xkb->ctrls->enabled_ctrls == XACCESS_CODE) { active = TRUE; } else { active = FALSE; } } // begin table message += "<br><br><table border=1 bgcolor=lightgrey "; message += "cellspacing=1 width=90%>"; message += idents; // first row message += "<tr>"; if (active) { QTextOStream (&idents) <<"<td width=200>"<< mText["xaccess"] <<" "<< mText["on"] <<"</td>"; } else { QTextOStream (&idents) <<"<td width=200>"<< mText["xaccess"] <<" "<< mText["off"] <<"</td>"; } message += idents; message += "</tr>"; // end table... message += "</table>"; info -> setText (message); } }
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; } }
std::string XKeyboard::get_kb_string() { XkbGetControls(_display, XkbAllControlsMask, _kbdDescPtr); XkbGetNames(_display, XkbSymbolsNameMask, _kbdDescPtr); Atom symNameAtom = _kbdDescPtr->names->symbols; CHECK(symNameAtom != None); char* kbsC = XGetAtomName(_display, symNameAtom); std::string kbs(kbsC); XFree(kbsC); CHECK(!kbs.empty()); return kbs; /* StringVector symNames; */ /* XkbSymbolParser symParser; */ /* symParser.parse(symName, symNames); */ /* return symNames; */ }
//===================================== // XKeyboard auto repeat set //------------------------------------- void XKeyboard::autoRepeat ( void ) { // log(L_INFO,"XKeyboard::autoRepeat() called\n"); // ... // This function is called if either the repeat or // delay rate has changed. We will use xset to apply // the new rate/delay values to the X-Server. The // function is called after the slider has been // released // --- XkbDescPtr xkb; int major = XkbMajorVersion; int minor = XkbMinorVersion; int op, event, error; int timeout = 500; Display* dpy = QApplication::desktop()->x11Display(); if (XkbQueryExtension(dpy, &op, &event, &error, &major, &minor) == 0) { log (L_INFO,"XKeyboard::Unable to initialize XKB extension"); return; } while (timeout > 0) { xkb = XkbGetKeyboard ( dpy, XkbGBN_AllComponentsMask, XkbUseCoreKbd ); if (xkb == NULL || xkb->geom == NULL) { timeout -= 1; usleep(100); } else { break; } } if (timeout <= 0) { log (L_INFO,"XKeyboard::Couldn't get keyboard\n"); return; } XkbGetControls (dpy, XkbRepeatKeysMask, xkb); xkb->ctrls->repeat_delay = mDelay->value(); xkb->ctrls->repeat_interval = 1000/mRepeat->value(); XkbSetControls ( dpy, XkbRepeatKeysMask, xkb ); XSync (dpy, False); }
void set_repeatrate(int delay, double rate) { #if HAVE_XKB Display* dpy = qt_xdisplay(); int xkbmajor = XkbMajorVersion, xkbminor = XkbMinorVersion; int xkbopcode, xkbevent, xkberror; if (XkbQueryExtension(dpy, &xkbopcode, &xkbevent, &xkberror, &xkbmajor, &xkbminor)) { XkbDescPtr xkb = XkbAllocKeyboard(); if (xkb) { 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); return; } } #endif // Fallback: use the xset utility. // Unfortunately xset does only support int parameters, so // really slow repeat rates cannot be supported this way. // (the FSG Accessibility standard requires support for repeat rates // of several seconds per character) int r; if (rate < 1) r = 1; else r = (int)floor(rate + 0.5); QString exe = KGlobal::dirs()->findExe("xset"); if (exe.isEmpty()) return; KProcess p; p << exe << "r" << "rate" << QString::number(delay) << QString::number(r); p.start(KProcess::Block); }
static void accessx_status_applet_notify_xkb_controls(AccessxStatusApplet* sapplet, XkbControlsNotifyEvent* event) { unsigned int mask = XkbStickyKeysMask | XkbSlowKeysMask | XkbBounceKeysMask | XkbMouseKeysMask; unsigned int notify_mask = 0; XkbGetControls(sapplet->xkb_display, XkbMouseKeysMask, sapplet->xkb); if (event->enabled_ctrl_changes & mask) { notify_mask = ACCESSX_STATUS_ENABLED; } if (event->changed_ctrls & XkbMouseKeysMask) { notify_mask |= ACCESSX_STATUS_MOUSEKEYS; } if (notify_mask) { accessx_status_applet_update(sapplet, notify_mask, (XkbEvent*) event); } }
//===================================== // XAccessX slotRun... //------------------------------------- bool XAccessX::slotRun (int index) { if (XTemplate::slotRun (index)) { // log(L_INFO,"XAccessX::slotRun() called: %d\n",index); // ... // this function is called if the xaccess page is activated. // use this function to init the dialog with the current // setup of the accessx status information // --- XWrapPointer< QDict<char> > mText (mTextPtr); mStatus -> message (mText["RunXAccess"]); mFrame -> nextButton() -> setText (mText["finish"]); // ... // if AccessX is active we will set the current speed // value here otherwhise the slider is disabled // --- XkbGetControls(x11Display(), XkbAllControlsMask, xkb); if (xkb->ctrls == NULL) { xkb->ctrls = (XkbControlsPtr)malloc(sizeof(XkbControlsRec)); isActive = FALSE; } else { if (XACCESS_CODE(xkb)) { isActive = TRUE; } else { isActive = FALSE; } } if (isActive) { slotState (true); mEnable -> setChecked ( true ); mSpeed -> setValue ( xkb->ctrls->mk_max_speed ); } else { mEnable -> setChecked ( false ); mDisable -> setChecked ( true ); slotState (false); } } return (TRUE); }
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; }
static void global_filter_fn (XEvent *xevent, void *data) { SpiDEController *controller; DEControllerPrivateData *priv; Display *display = spi_get_display (); controller = SPI_DEVICE_EVENT_CONTROLLER (data); priv = controller->priv; if (xevent->type == MappingNotify) xmkeymap = NULL; if (xevent->type == KeyPress || xevent->type == KeyRelease) { if (priv->xevie_display == NULL) { gboolean is_consumed; is_consumed = spi_device_event_controller_forward_key_event (controller, xevent); if (is_consumed) { int n_events; int i; XEvent next_event; n_events = XPending (display); #ifdef SPI_KEYEVENT_DEBUG g_print ("Number of events pending: %d\n", n_events); #endif for (i = 0; i < n_events; i++) { XNextEvent (display, &next_event); if (next_event.type != KeyPress && next_event.type != KeyRelease) g_warning ("Unexpected event type %d in queue", next_event.type); } XAllowEvents (display, AsyncKeyboard, CurrentTime); if (n_events) XUngrabKeyboard (display, CurrentTime); } else { if (xevent->type == KeyPress) wait_for_release_event (xevent, controller); XAllowEvents (display, ReplayKeyboard, CurrentTime); } } return; } if (xevent->type == ButtonPress || xevent->type == ButtonRelease) { spi_device_event_controller_forward_mouse_event (controller, xevent); } if (xevent->type == priv->xkb_base_event_code) { XkbAnyEvent * xkb_ev = (XkbAnyEvent *) xevent; /* ugly but probably necessary...*/ XSynchronize (display, TRUE); if (xkb_ev->xkb_type == XkbStateNotify) { XkbStateNotifyEvent *xkb_snev = (XkbStateNotifyEvent *) xkb_ev; /* check the mouse, to catch mouse events grabbed by * another client; in case we should revert this XKB delatch */ if (!priv->pending_xkb_mod_relatch_mask) { int x, y; gboolean moved; spi_dec_x11_mouse_check (controller, &x, &y, &moved); } /* we check again, since the previous call may have changed this flag */ if (priv->pending_xkb_mod_relatch_mask) { unsigned int feedback_mask; #ifdef SPI_XKB_DEBUG fprintf (stderr, "relatching %x\n", priv->pending_xkb_mod_relatch_mask); #endif /* temporarily turn off the latch bell, if it's on */ XkbGetControls (display, XkbAccessXFeedbackMask, priv->xkb_desc); feedback_mask = priv->xkb_desc->ctrls->ax_options; if (feedback_mask & XkbAX_StickyKeysFBMask) { XkbControlsChangesRec changes = {XkbAccessXFeedbackMask, 0, False}; priv->xkb_desc->ctrls->ax_options &= ~(XkbAX_StickyKeysFBMask); XkbChangeControls (display, priv->xkb_desc, &changes); } /* TODO: account for lock as well as latch */ XkbLatchModifiers (display, XkbUseCoreKbd, priv->pending_xkb_mod_relatch_mask, priv->pending_xkb_mod_relatch_mask); if (feedback_mask & XkbAX_StickyKeysFBMask) { XkbControlsChangesRec changes = {XkbAccessXFeedbackMask, 0, False}; priv->xkb_desc->ctrls->ax_options = feedback_mask; XkbChangeControls (display, priv->xkb_desc, &changes); } #ifdef SPI_XKB_DEBUG fprintf (stderr, "relatched %x\n", priv->pending_xkb_mod_relatch_mask); #endif priv->pending_xkb_mod_relatch_mask = 0; } else { priv->xkb_latch_mask = xkb_snev->latched_mods; } } XSynchronize (display, FALSE); } return; }
int xnestKeyboardProc(DeviceIntPtr pDev, int onoff) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; KeySymsRec keySyms; CARD8 modmap[MAP_LENGTH]; int i, j; XKeyboardState values; XkbDescPtr xkb; int op, event, error, major, minor; switch (onoff) { case DEVICE_INIT: XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode); #ifdef _XSERVER64 { KeySym64 *keymap64; int len; keymap64 = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); len = (max_keycode - min_keycode + 1) * mapWidth; keymap = xallocarray(len, sizeof(KeySym)); for (i = 0; i < len; ++i) keymap[i] = keymap64[i]; XFree(keymap64); } #else keymap = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); #endif memset(modmap, 0, sizeof(modmap)); modifier_keymap = XGetModifierMapping(xnestDisplay); 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; if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) { ErrorF("Unable to initialize XKEYBOARD extension.\n"); goto XkbError; } xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { ErrorF("Couldn't get keyboard.\n"); goto XkbError; } XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode, keySyms.maxKeyCode - keySyms.minKeyCode + 1, modmap, serverClient); XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls); XkbFreeKeyboard(xkb, 0, False); free(keymap); break; case DEVICE_ON: xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_OFF: xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_CLOSE: break; } return Success; XkbError: XGetKeyboardControl(xnestDisplay, &values); memmove((char *) defaultKeyboardControl.autoRepeats, (char *) values.auto_repeats, sizeof(values.auto_repeats)); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); free(keymap); return Success; }
static void xfce_accessibility_helper_set_xkb (XfceAccessibilityHelper *helper, gulong mask) { XkbDescPtr xkb; gint delay, interval, time_to_max; gint max_speed, curve; gdk_error_trap_push (); /* allocate */ xkb = XkbAllocKeyboard (); if (G_LIKELY (xkb)) { /* we always change this, so add it to the mask */ SET_FLAG (mask, XkbControlsEnabledMask); /* if setting sticky keys, we set expiration too */ if (HAS_FLAG (mask, XkbStickyKeysMask) || HAS_FLAG (mask, XkbSlowKeysMask) || HAS_FLAG (mask, XkbBounceKeysMask) || HAS_FLAG (mask, XkbMouseKeysMask) || HAS_FLAG (mask, XkbAccessXKeysMask)) SET_FLAG (mask, XkbAccessXTimeoutMask); /* add the mouse keys values mask if needed */ if (HAS_FLAG (mask, XkbMouseKeysMask)) SET_FLAG (mask, XkbMouseKeysAccelMask); /* load the xkb controls into the structure */ XkbGetControls (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), mask, xkb); /* AccessXKeys */ if (HAS_FLAG (mask, XkbAccessXKeysMask)) { if (xfconf_channel_get_bool (helper->channel, "/AccessXKeys", FALSE)) { SET_FLAG (xkb->ctrls->enabled_ctrls, XkbAccessXKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbAccessXKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbAccessXKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "AccessXKeys enabled"); } else { UNSET_FLAG (xkb->ctrls->enabled_ctrls, XkbAccessXKeysMask); SET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbAccessXKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbAccessXKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "AccessXKeys disabled"); } } /* Sticky keys */ if (HAS_FLAG (mask, XkbStickyKeysMask)) { if (xfconf_channel_get_bool (helper->channel, "/StickyKeys", FALSE)) { SET_FLAG (xkb->ctrls->enabled_ctrls, XkbStickyKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbStickyKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbStickyKeysMask); if (xfconf_channel_get_bool (helper->channel, "/StickyKeys/LatchToLock", FALSE)) SET_FLAG (xkb->ctrls->ax_options, XkbAX_LatchToLockMask); else UNSET_FLAG (xkb->ctrls->ax_options, XkbAX_LatchToLockMask); if (xfconf_channel_get_bool (helper->channel, "/StickyKeys/TwoKeysDisable", FALSE)) SET_FLAG (xkb->ctrls->ax_options, XkbAX_TwoKeysMask); else UNSET_FLAG (xkb->ctrls->ax_options, XkbAX_TwoKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "stickykeys enabled (ax_options=%d)", xkb->ctrls->ax_options); } else { UNSET_FLAG (xkb->ctrls->enabled_ctrls, XkbStickyKeysMask); SET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbStickyKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbStickyKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "stickykeys disabled"); } } /* Slow keys */ if (HAS_FLAG (mask, XkbSlowKeysMask)) { if (xfconf_channel_get_bool (helper->channel, "/SlowKeys", FALSE)) { SET_FLAG (xkb->ctrls->enabled_ctrls, XkbSlowKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbSlowKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbSlowKeysMask); delay = xfconf_channel_get_int (helper->channel, "/SlowKeys/Delay", 100); xkb->ctrls->slow_keys_delay = CLAMP (delay, 1, G_MAXUSHORT); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "slowkeys enabled (delay=%d)", xkb->ctrls->slow_keys_delay); } else { UNSET_FLAG (xkb->ctrls->enabled_ctrls, XkbSlowKeysMask); SET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbSlowKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbSlowKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "slowkeys disabled"); } } /* Bounce keys */ if (HAS_FLAG (mask, XkbBounceKeysMask)) { if (xfconf_channel_get_bool (helper->channel, "/BounceKeys", FALSE)) { SET_FLAG (xkb->ctrls->enabled_ctrls, XkbBounceKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbBounceKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbBounceKeysMask); delay = xfconf_channel_get_int (helper->channel, "/BounceKeys/Delay", 100); xkb->ctrls->debounce_delay = CLAMP (delay, 1, G_MAXUSHORT); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "bouncekeys enabled (delay=%d)", xkb->ctrls->debounce_delay); } else { UNSET_FLAG (xkb->ctrls->enabled_ctrls, XkbBounceKeysMask); SET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbBounceKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbBounceKeysMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "bouncekeys disabled"); } } /* Mouse keys */ if (HAS_FLAG (mask, XkbMouseKeysMask)) { if (xfconf_channel_get_bool (helper->channel, "/MouseKeys", FALSE)) { SET_FLAG (xkb->ctrls->enabled_ctrls, XkbMouseKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbMouseKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbMouseKeysMask); /* get values */ delay = xfconf_channel_get_int (helper->channel, "/MouseKeys/Delay", 160); interval = xfconf_channel_get_int (helper->channel, "/MouseKeys/Interval", 20); time_to_max = xfconf_channel_get_int (helper->channel, "/MouseKeys/TimeToMax", 3000); max_speed = xfconf_channel_get_int (helper->channel, "/MouseKeys/MaxSpeed", 1000); curve = xfconf_channel_get_int (helper->channel, "/MouseKeys/Curve", 0); /* calculate maximum speed and to to reach it */ interval = CLAMP (interval, 1, G_MAXUSHORT); max_speed = (max_speed * interval) / 1000; time_to_max = (time_to_max + interval / 2) / interval; /* set new values, clamp to limits */ xkb->ctrls->mk_delay = CLAMP (delay, 1, G_MAXUSHORT); xkb->ctrls->mk_interval = interval; xkb->ctrls->mk_time_to_max = CLAMP (time_to_max, 1, G_MAXUSHORT); xkb->ctrls->mk_max_speed = CLAMP (max_speed, 1, G_MAXUSHORT); xkb->ctrls->mk_curve = CLAMP (curve, -1000, 1000); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "mousekeys enabled (delay=%d, interval=%d, " "time_to_max=%d, max_speed=%d, curve=%d)", xkb->ctrls->mk_delay, xkb->ctrls->mk_interval, xkb->ctrls->mk_time_to_max, xkb->ctrls->mk_max_speed, xkb->ctrls->mk_curve); } else { UNSET_FLAG (xkb->ctrls->enabled_ctrls, XkbMouseKeysMask); SET_FLAG (xkb->ctrls->axt_ctrls_mask, XkbMouseKeysMask); UNSET_FLAG (xkb->ctrls->axt_ctrls_values, XkbMouseKeysMask); UNSET_FLAG (mask, XkbMouseKeysAccelMask); xfsettings_dbg (XFSD_DEBUG_ACCESSIBILITY, "mousekeys disabled"); } } /* set the modified controls */ if (!XkbSetControls (GDK_DISPLAY_XDISPLAY(gdk_display_get_default()), mask, xkb)) g_message ("Setting the xkb controls failed"); /* free the structure */ XkbFreeControls (xkb, mask, True); XFree (xkb); } else { /* warning */ g_critical ("XkbAllocKeyboard() returned a null pointer"); } if (gdk_error_trap_pop () != 0) g_critical ("Failed to set keyboard controls"); }
int xnestKeyboardProc(DeviceIntPtr pDev, int onoff) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; KeySymsRec keySyms; CARD8 modmap[MAP_LENGTH]; int i, j; XKeyboardState values; switch (onoff) { case DEVICE_INIT: modifier_keymap = XGetModifierMapping(xnestDisplay); XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode); #ifdef _XSERVER64 { KeySym64 *keymap64; int i, len; keymap64 = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); len = (max_keycode - min_keycode + 1) * mapWidth; keymap = (KeySym *)xalloc(len * sizeof(KeySym)); for(i = 0; i < len; ++i) keymap[i] = keymap64[i]; XFree(keymap64); } #else keymap = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); #endif for (i = 0; i < MAP_LENGTH; i++) modmap[i] = 0; 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; #ifdef XKB if (noXkbExtension) { XkbError: #endif XGetKeyboardControl(xnestDisplay, &values); memmove((char *) defaultKeyboardControl.autoRepeats, (char *) values.auto_repeats, sizeof(values.auto_repeats)); InitKeyboardDeviceStruct(&pDev->public, &keySyms, modmap, xnestBell, xnestChangeKeyboardControl); #ifdef XKB } else { FILE *file; XkbConfigRtrnRec config; XkbComponentNamesRec names; char *rules, *model, *layout, *variants, *options; XkbDescPtr xkb; int op, event, error, major, minor; if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) { ErrorF("Unable to initialize XKEYBOARD extension.\n"); goto XkbError; } xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { ErrorF("Couldn't get keyboard.\n"); goto XkbError; } XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb); memset(&names, 0, sizeof(XkbComponentNamesRec)); rules = XKB_DFLT_RULES_FILE; model = XKB_DFLT_KB_MODEL; layout = XKB_DFLT_KB_LAYOUT; variants = XKB_DFLT_KB_VARIANT; options = XKB_DFLT_KB_OPTIONS; if (XkbInitialMap) { if ((names.keymap = strchr(XkbInitialMap, '/')) != NULL) ++names.keymap; else names.keymap = XkbInitialMap; } XkbSetRulesDflts(rules, model, layout, variants, options); XkbInitKeyboardDeviceStruct(pDev, &names, &keySyms, modmap, xnestBell, xnestChangeKeyboardControl); XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls); XkbFreeKeyboard(xkb, 0, False); } #endif #ifdef _XSERVER64 xfree(keymap); #else XFree(keymap); #endif break; case DEVICE_ON: xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_OFF: xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_CLOSE: break; }