//=====================================
// 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");
}
