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