//===================================== // XAccessX apply access X //------------------------------------- void XAccessX::slotApply (void) { // log (L_INFO,"XAccessX::slotApply() called\n"); // ... // this function is called if the apply button // is pressed. We will check the check button // if accessX should be enabled/disabled // --- bool active = true; xkb->ctrls->enabled_ctrls |= XkbMouseKeysMask | XkbMouseKeysAccelMask; // ... // standard values // --- xkb->ctrls->mk_delay = 40; xkb->ctrls->mk_interval = 10; xkb->ctrls->mk_time_to_max = 1000; xkb->ctrls->mk_curve = 0; if (mEnable -> isChecked()) { xkb->ctrls->mk_max_speed = mLCD -> intValue(); } else { xkb->ctrls->enabled_ctrls &= ~(XkbMouseKeysMask | XkbMouseKeysAccelMask); active = false; } // ... // set controls now // --- XkbSetControls ( x11Display(), XkbAllControlsMask, xkb ); XSync (x11Display(), False); XWrapPointer< QDict<char> > mText (mTextPtr); QString message; if (active) { message = mText["ACCXEnabled"]; } else { message = mText["ACCXDisabled"]; } XBox mb ( mText["ACCXInfo"],message, XBox::Information, XBox::Yes, 0,0,mFrame, globalFrameWidth ); mb.setButtonText ( XBox::Yes,mText["Ok"] ); mb.exec(); mFrame -> enterEvent ( 0 ); }
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; }
//======================================== // 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 XkbWriteToServer(XkbFileInfo *result) { XkbDescPtr xkb; Display * dpy; if ((result==NULL)||(result->xkb==NULL)||(result->xkb->dpy==NULL)) return False; xkb= result->xkb; dpy= xkb->dpy; if (!XkbSetMap(dpy,XkbAllMapComponentsMask,xkb)) return False; if (!XkbSetIndicatorMap(dpy,~0,xkb)) return False; #ifdef NOTYET if (!XkbSetControls(dpy,XkbAllControlsMask,xkb)) return False; #endif if (!XkbSetCompatMap(dpy,XkbAllCompatMask,xkb,True)) return False; if (!XkbSetNames(dpy,XkbAllNamesMask,0,xkb->map->num_types,xkb)) return False; if (xkb->geom) { if (XkbSetGeometry(dpy,xkb->device_spec,xkb->geom)!=Success) return False; } return True; #ifdef NOTYET switch (result->type) { case XkmSemanticsFile: func= WriteCHdrSemantics; break; case XkmLayoutFile: func= WriteCHdrLayout; break; case XkmKeymapFile: func= WriteCHdrKeymap; break; default: _XkbLibError(_XkbErrIllegalContents,"XkbWriteToServer",result->type); break; } return ok; #endif }
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; } }
//===================================== // 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 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"); }