xorg-server-1.4/hw/xfree86/utils/xorgcfg/accessx.c

   1 /*
   2  * Copyright (c) 2000 by Conectiva S.A. (http://www.conectiva.com)
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * CONECTIVA LINUX BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  *
  22  * Except as contained in this notice, the name of Conectiva Linux shall
  23  * not be used in advertising or otherwise to promote the sale, use or other
  24  * dealings in this Software without prior written authorization from
  25  * Conectiva Linux.
  26  *
  27  * Author: Paulo César Pereira de Andrade <pcpa@conectiva.com.br>
  28  *
  29  */
  30
  31 #include "config.h"
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34 #include <signal.h>
  35 #include <X11/XKBlib.h>
  36 #include <X11/Shell.h>
  37 #include <X11/Xaw/Command.h>
  38 #include <X11/Xaw/Form.h>
  39 #include <X11/Xaw/Label.h>
  40 #include <X11/Xaw/Scrollbar.h>
  41 #include <X11/Xaw/Toggle.h>
  42 #include "keyboard-cfg.h"
  43
  44 #define MAX_TIMEOUT             20
  45 #define MAX_MOUSE_SPEED         500
  46 #define MAX_MOUSE_TIME          4
  47 #define MAX_MOUSE_DELAY         2.09
  48 #define MAX_REPEAT_RATE         8.04
  49 #define MAX_REPEAT_DELAY        6.04
  50 #define MAX_SLOW_TIME           4
  51 #define MAX_BOUNCE_TIME         4
  52
  53 /*
  54  * Types
  55  */
  56 typedef struct {
  57     Widget label, number, scroller;
  58     double min, max, value, resolution;
  59     Bool integer;
  60 } Scale;
  61
  62 /*
  63  * Initialization
  64  */
  65 static Widget shell, accessx, enable, timeoutToggle, form, apply;
  66 static Widget sticky, stickyAuto, stickyBeep;
  67 static Widget mouse;
  68 static Widget repeat;
  69 static Widget slowToggle, slowPressed, slowAccepted;
  70 static Widget bounceToggle;
  71 static Scale *timeout, *mouseSpeed, *mouseTime, *mouseDelay, *slow,
  72         *repeatRate, *repeatDelay, *bounce;
  73 extern Widget work;
  74
  75 /*
  76  * Prototypes
  77  */
  78 static void CreateAccessXHelpDialog(void);
  79 static void EnableCallback(Widget, XtPointer, XtPointer);
  80 static void ScaleEnableCallback(Widget, XtPointer, XtPointer);
  81 static void ScaleJumpCallback(Widget, XtPointer, XtPointer);
  82
  83 static void ApplyCallback(Widget, XtPointer, XtPointer);
  84 static void AccessXInitialize(void);
  85
  86 void CloseAccessXAction(Widget, XEvent*, String*, Cardinal*);
  87 void AccessXConfigureStart(void);
  88 void AccessXConfigureEnd(void);
  89
  90 /*
  91  * Implementation
  92  */
  93 void
  94 startaccessx(void)
  95 {
  96     InitializeKeyboard();
  97
  98     if (xkb_info->xkb) {
  99         XkbGetControls(DPY, XkbAllControlsMask, xkb_info->xkb);
 100         if (xkb_info->xkb->ctrls == NULL)
 101             xkb_info->xkb->ctrls = (XkbControlsPtr)
 102                 XtCalloc(1, sizeof(XkbControlsRec));
 103
 104         xkb_info->xkb->ctrls->enabled_ctrls |= XkbMouseKeysMask |
 105                                                XkbMouseKeysAccelMask;
 106         xkb_info->xkb->ctrls->mk_delay = 40;
 107         xkb_info->xkb->ctrls->mk_interval = 10;
 108         xkb_info->xkb->ctrls->mk_time_to_max = 1000;
 109         xkb_info->xkb->ctrls->mk_max_speed = 500;
 110         xkb_info->xkb->ctrls->mk_curve = 0;
 111         XkbSetControls(DPY, XkbAllControlsMask, xkb_info->xkb);
 112         (void)UpdateKeyboard(True);
 113         CreateAccessXHelpDialog();
 114     }
 115 }
 116
 117 void
 118 CreateAccessXHelpDialog()
 119 {
 120     Widget form;
 121
 122     shell = XtVaCreatePopupShell("accessx", transientShellWidgetClass, toplevel,
 123                                  XtNx, toplevel->core.x + toplevel->core.width,
 124                                  XtNy, toplevel->core.y, NULL);
 125     form = XtCreateManagedWidget("form", formWidgetClass, shell, NULL, 0);
 126     XtCreateManagedWidget("label", labelWidgetClass, form, NULL, 0);
 127     XtCreateManagedWidget("lock", labelWidgetClass, form, NULL, 0);
 128     XtCreateManagedWidget("div", labelWidgetClass, form, NULL, 0);
 129     XtCreateManagedWidget("mul", labelWidgetClass, form, NULL, 0);
 130     XtCreateManagedWidget("minus", labelWidgetClass, form, NULL, 0);
 131     XtCreateManagedWidget("7", labelWidgetClass, form, NULL, 0);
 132     XtCreateManagedWidget("8", labelWidgetClass, form, NULL, 0);
 133     XtCreateManagedWidget("9", labelWidgetClass, form, NULL, 0);
 134     XtCreateManagedWidget("plus", labelWidgetClass, form, NULL, 0);
 135     XtCreateManagedWidget("4", labelWidgetClass, form, NULL, 0);
 136     XtCreateManagedWidget("5", labelWidgetClass, form, NULL, 0);
 137     XtCreateManagedWidget("6", labelWidgetClass, form, NULL, 0);
 138     XtCreateManagedWidget("1", labelWidgetClass, form, NULL, 0);
 139     XtCreateManagedWidget("2", labelWidgetClass, form, NULL, 0);
 140     XtCreateManagedWidget("3", labelWidgetClass, form, NULL, 0);
 141     XtCreateManagedWidget("enter", labelWidgetClass, form, NULL, 0);
 142     XtCreateManagedWidget("0", labelWidgetClass, form, NULL, 0);
 143     XtCreateManagedWidget("del", labelWidgetClass, form, NULL, 0);
 144
 145     XtRealizeWidget(shell);
 146     XSetWMProtocols(DPY, XtWindow(shell), &wm_delete_window, 1);
 147     XtPopup(shell, XtGrabNone);
 148 }
 149
 150 /*ARGSUSED*/
 151 void
 152 CloseAccessXAction(Widget w, XEvent *event, String *params, Cardinal *num_params)
 153 {
 154     XtPopdown(shell);
 155 }
 156
 157 static void
 158 AccessXInitialize(void)
 159 {
 160     static int first = 1;
 161     Arg args[1];
 162     Boolean state;
 163     Widget stickyForm, mouseForm, repeatForm, slowForm, bounceForm;
 164     float val, tmp;
 165
 166     if (!first)
 167         return;
 168     first = 0;
 169
 170     InitializeKeyboard();
 171
 172     XkbGetControls(DPY, XkbAllControlsMask, xkb_info->xkb);
 173     if (xkb_info->xkb->ctrls == NULL)
 174         xkb_info->xkb->ctrls = (XkbControlsPtr)
 175             XtCalloc(1, sizeof(XkbControlsRec));
 176
 177     timeout = XtNew(Scale);
 178     accessx = XtCreateWidget("accessxForm", formWidgetClass, work, NULL, 0);
 179     enable = XtVaCreateManagedWidget("enable", toggleWidgetClass, accessx,
 180                                      XtNstate,
 181                                      (xkb_info->xkb->ctrls->enabled_ctrls &
 182                                       (XkbAccessXKeysMask | XkbStickyKeysMask |
 183                                        XkbSlowKeysMask | XkbBounceKeysMask)) != 0, NULL);
 184
 185     apply = XtCreateManagedWidget("apply", commandWidgetClass, accessx, NULL, 0);
 186     XtAddCallback(apply, XtNcallback, ApplyCallback, NULL);
 187
 188     form = XtCreateManagedWidget("Accessx", formWidgetClass, accessx, NULL, 0);
 189     timeoutToggle = XtVaCreateManagedWidget("timeoutToggle", toggleWidgetClass,
 190                                             form, XtNstate,
 191                                             xkb_info->xkb->ctrls->ax_timeout > 60
 192                                             && xkb_info->xkb->ctrls->ax_timeout
 193                                             < 30000, NULL);
 194     XtAddCallback(timeoutToggle, XtNcallback, ScaleEnableCallback,
 195                   (XtPointer)timeout);
 196     timeout->label = XtCreateManagedWidget("timeoutLabel", labelWidgetClass,
 197                                            form, NULL, 0);
 198     timeout->number = XtCreateManagedWidget("timeoutNumber", labelWidgetClass,
 199                                             form, NULL, 0);
 200     timeout->scroller = XtCreateManagedWidget("timeoutScroller",
 201                                               scrollbarWidgetClass,
 202                                               form, NULL, 0);
 203     XtAddCallback(timeout->scroller, XtNjumpProc, ScaleJumpCallback,
 204                   (XtPointer)timeout);
 205     timeout->min = 1;
 206     timeout->max = MAX_TIMEOUT;
 207     timeout->resolution = 1;
 208     timeout->integer = True;
 209
 210     sticky = XtVaCreateManagedWidget("sticky", toggleWidgetClass, form,
 211                                      XtNstate,
 212                                      (xkb_info->xkb->ctrls->enabled_ctrls &
 213                                       XkbStickyKeysMask) != 0, NULL);
 214     stickyForm = XtCreateManagedWidget("stickyForm", formWidgetClass,
 215                                        form, NULL, 0);
 216     XtAddCallback(sticky, XtNcallback, EnableCallback, (XtPointer)stickyForm);
 217     stickyAuto = XtVaCreateManagedWidget("auto", toggleWidgetClass, stickyForm,
 218                                          XtNstate,
 219                                          (xkb_info->xkb->ctrls->ax_options &
 220                                           XkbAX_LatchToLockMask) == 0, NULL);
 221     stickyBeep = XtVaCreateManagedWidget("beep", toggleWidgetClass, stickyForm,
 222                                          XtNstate,
 223                                          (xkb_info->xkb->ctrls->ax_options &
 224                                           XkbAX_StickyKeysFBMask) != 0, NULL);
 225
 226     mouse = XtVaCreateManagedWidget("mouseKeys", toggleWidgetClass, form,
 227                                     XtNstate,
 228                                     (xkb_info->xkb->ctrls->enabled_ctrls &
 229                                      (XkbMouseKeysMask | XkbMouseKeysAccelMask))
 230                                     != 0, NULL);
 231     mouseForm = XtCreateManagedWidget("mouseForm", formWidgetClass,
 232                                       form, NULL, 0);
 233     XtAddCallback(mouse, XtNcallback, EnableCallback, (XtPointer)mouseForm);
 234     mouseSpeed = XtNew(Scale);
 235     mouseSpeed->label = XtCreateManagedWidget("speedLabel", labelWidgetClass,
 236                                               mouseForm, NULL, 0);
 237     mouseSpeed->number = XtCreateManagedWidget("speedNumber", labelWidgetClass,
 238                                               mouseForm, NULL, 0);
 239     mouseSpeed->scroller = XtCreateManagedWidget("speedScroller",
 240                                                  scrollbarWidgetClass,
 241                                                  mouseForm, NULL, 0);
 242     XtAddCallback(mouseSpeed->scroller, XtNjumpProc, ScaleJumpCallback,
 243                   (XtPointer)mouseSpeed);
 244     mouseSpeed->min = 10;
 245     mouseSpeed->max = MAX_MOUSE_SPEED;
 246     mouseSpeed->resolution = 10;
 247     mouseSpeed->integer = True;
 248     mouseTime = XtNew(Scale);
 249     mouseTime->label = XtCreateManagedWidget("timeLabel", labelWidgetClass,
 250                                              mouseForm, NULL, 0);
 251     mouseTime->number = XtCreateManagedWidget("timeNumber", labelWidgetClass,
 252                                               mouseForm, NULL, 0);
 253     mouseTime->scroller = XtCreateManagedWidget("timeScroller",
 254                                                 scrollbarWidgetClass,
 255                                                 mouseForm, NULL, 0);
 256     XtAddCallback(mouseTime->scroller, XtNjumpProc, ScaleJumpCallback,
 257                   (XtPointer)mouseTime);
 258     mouseTime->min = .1;
 259     mouseTime->max = MAX_MOUSE_TIME;
 260     mouseTime->resolution = .1;
 261     mouseTime->integer = False;
 262     mouseDelay = XtNew(Scale);
 263     mouseDelay->label = XtCreateManagedWidget("delayLabel", labelWidgetClass,
 264                                               mouseForm, NULL, 0);
 265     mouseDelay->number = XtCreateManagedWidget("delayNumber", labelWidgetClass,
 266                                                mouseForm, NULL, 0);
 267     mouseDelay->scroller = XtCreateManagedWidget("delayScroller",
 268                                                  scrollbarWidgetClass,
 269                                                  mouseForm, NULL, 0);
 270     XtAddCallback(mouseDelay->scroller, XtNjumpProc, ScaleJumpCallback,
 271                   (XtPointer)mouseDelay);
 272     mouseDelay->min = .1;
 273     mouseDelay->max = MAX_MOUSE_DELAY;
 274     mouseDelay->resolution = .1;
 275     mouseDelay->integer = False;
 276
 277     repeat = XtVaCreateManagedWidget("repeatKeys", toggleWidgetClass, form,
 278                                      XtNstate,
 279                                     (xkb_info->xkb->ctrls->enabled_ctrls &
 280                                      XkbRepeatKeysMask) != 0, NULL);
 281     repeatForm = XtCreateManagedWidget("repeatForm", formWidgetClass,
 282                                        form, NULL, 0);
 283     XtAddCallback(repeat, XtNcallback, EnableCallback, (XtPointer)repeatForm);
 284     repeatRate = XtNew(Scale);
 285     repeatRate->label = XtCreateManagedWidget("rateLabel", labelWidgetClass,
 286                                               repeatForm, NULL, 0);
 287     repeatRate->number = XtCreateManagedWidget("rateNumber", labelWidgetClass,
 288                                                repeatForm, NULL, 0);
 289     repeatRate->scroller = XtCreateManagedWidget("rateScroller",
 290                                                  scrollbarWidgetClass,
 291                                                  repeatForm, NULL, 0);
 292     XtAddCallback(repeatRate->scroller, XtNjumpProc, ScaleJumpCallback,
 293                   (XtPointer)repeatRate);
 294     repeatRate->min = .05;
 295     repeatRate->max = MAX_REPEAT_RATE;
 296     repeatRate->resolution = .05;
 297     repeatRate->integer = False;
 298     repeatDelay = XtNew(Scale);
 299     repeatDelay->label = XtCreateManagedWidget("delayLabel", labelWidgetClass,
 300                                               repeatForm, NULL, 0);
 301     repeatDelay->number = XtCreateManagedWidget("delayNumber", labelWidgetClass,
 302                                                repeatForm, NULL, 0);
 303     repeatDelay->scroller = XtCreateManagedWidget("delayScroller",
 304                                                  scrollbarWidgetClass,
 305                                                  repeatForm, NULL, 0);
 306     XtAddCallback(repeatDelay->scroller, XtNjumpProc, ScaleJumpCallback,
 307                   (XtPointer)repeatDelay);
 308     repeatDelay->min = .05;
 309     repeatDelay->max = MAX_REPEAT_DELAY;
 310     repeatDelay->resolution = .05;
 311     repeatDelay->integer = False;
 312
 313     slowToggle = XtVaCreateManagedWidget("slow", toggleWidgetClass,
 314                                          form, XtNstate,
 315                                          (xkb_info->xkb->ctrls->enabled_ctrls &
 316                                          XkbSlowKeysMask) != 0, NULL);
 317     slowForm = XtCreateManagedWidget("slowForm", formWidgetClass,
 318                                      form, NULL, 0);
 319     XtAddCallback(slowToggle, XtNcallback, EnableCallback, (XtPointer)slowForm);
 320     XtCreateManagedWidget("beep", labelWidgetClass, slowForm, NULL, 0);
 321     slowPressed = XtVaCreateManagedWidget("pressed", toggleWidgetClass,
 322                                           slowForm, XtNstate,
 323                                           (xkb_info->xkb->ctrls->ax_options &
 324                                           XkbAX_SKPressFBMask) != 0,
 325                                           NULL);
 326     slowAccepted = XtVaCreateManagedWidget("accepted", toggleWidgetClass,
 327                                            slowForm, XtNstate,
 328                                            (xkb_info->xkb->ctrls->ax_options &
 329                                            XkbAX_SKAcceptFBMask) != 0,
 330                                            NULL);
 331     slow = XtNew(Scale);
 332     slow->label = XtCreateManagedWidget("slowLabel", labelWidgetClass,
 333                                         slowForm, NULL, 0);
 334     slow->number = XtCreateManagedWidget("slowNumber", labelWidgetClass,
 335                                           slowForm, NULL, 0);
 336     slow->scroller = XtCreateManagedWidget("slowScroller",
 337                                            scrollbarWidgetClass,
 338                                            slowForm, NULL, 0);
 339     XtAddCallback(slow->scroller, XtNjumpProc, ScaleJumpCallback,
 340                   (XtPointer)slow);
 341     slow->min = 0.1;
 342     slow->max = MAX_SLOW_TIME;
 343     slow->resolution = 0.1;
 344     slow->integer = False;
 345
 346     bounceToggle = XtVaCreateManagedWidget("bounce", toggleWidgetClass,
 347                                            form, XtNstate,
 348                                            (xkb_info->xkb->ctrls->enabled_ctrls &
 349                                            XkbBounceKeysMask) != 0,
 350                                            NULL);
 351     bounceForm = XtCreateManagedWidget("bounceForm", formWidgetClass,
 352                                      form, NULL, 0);
 353     XtAddCallback(bounceToggle, XtNcallback, EnableCallback, (XtPointer)bounceForm);
 354     bounce = XtNew(Scale);
 355     bounce->label = XtCreateManagedWidget("bounceLabel", labelWidgetClass,
 356                                         bounceForm, NULL, 0);
 357     bounce->number = XtCreateManagedWidget("bounceNumber", labelWidgetClass,
 358                                           bounceForm, NULL, 0);
 359     bounce->scroller = XtCreateManagedWidget("bounceScroller",
 360                                            scrollbarWidgetClass,
 361                                            bounceForm, NULL, 0);
 362     XtAddCallback(bounce->scroller, XtNjumpProc, ScaleJumpCallback,
 363                   (XtPointer)bounce);
 364     bounce->min = 0.1;
 365     bounce->max = MAX_BOUNCE_TIME;
 366     bounce->resolution = 0.1;
 367     bounce->integer = False;
 368
 369     XtRealizeWidget(accessx);
 370
 371     XtSetArg(args[0], XtNstate, &state);
 372     XtGetValues(timeoutToggle, args, 1);
 373     ScaleEnableCallback(enable, (XtPointer)timeout, (XtPointer)(long)state);
 374     if (xkb_info->xkb->ctrls->ax_timeout > 60)
 375         val = (float)(xkb_info->xkb->ctrls->ax_timeout - 60) /
 376               (float)(MAX_TIMEOUT * 60);
 377     else
 378         val = 0;
 379     ScaleJumpCallback(timeout->scroller, (XtPointer)timeout, (XtPointer)&val);
 380
 381     XtSetArg(args[0], XtNstate, &state);
 382     XtGetValues(sticky, args, 1);
 383     EnableCallback(sticky, (XtPointer)stickyForm, (XtPointer)(long)state);
 384
 385     XtSetArg(args[0], XtNstate, &state);
 386     XtGetValues(mouse, args, 1);
 387     EnableCallback(mouse, (XtPointer)mouseForm, (XtPointer)(long)state);
 388     if (xkb_info->xkb->ctrls->mk_time_to_max > 10)
 389         val = (float)((xkb_info->xkb->ctrls->mk_time_to_max * (40. / 10.))) /
 390               (float)(MAX_MOUSE_TIME * 100);
 391     else
 392         val = 10.0 / (float)(MAX_MOUSE_TIME * 100);
 393     ScaleJumpCallback(mouseTime->scroller, (XtPointer)mouseTime,
 394                       (XtPointer)&val);
 395     tmp = mouseTime->value;
 396     if (xkb_info->xkb->ctrls->mk_max_speed != 0)
 397         val = (float)(xkb_info->xkb->ctrls->mk_max_speed / tmp - 10) /
 398               (float)MAX_MOUSE_SPEED;
 399     else
 400         val = 10.0 / (float)MAX_MOUSE_SPEED;
 401     ScaleJumpCallback(mouseSpeed->scroller, (XtPointer)mouseSpeed,
 402                       (XtPointer)&val);
 403     if (xkb_info->xkb->ctrls->mk_delay > 10)
 404         val = (float)(xkb_info->xkb->ctrls->mk_delay - 10) /
 405               (float)(MAX_MOUSE_DELAY * 100);
 406     else
 407         val = 10.0 / (float)(MAX_MOUSE_DELAY * 100);
 408     ScaleJumpCallback(mouseDelay->scroller, (XtPointer)mouseDelay,
 409                       (XtPointer)&val);
 410
 411     XtSetArg(args[0], XtNstate, &state);
 412     XtGetValues(repeat, args, 1);
 413     EnableCallback(repeat, (XtPointer)repeatForm, (XtPointer)(long)state);
 414     if (xkb_info->xkb->ctrls->repeat_interval > 5)
 415         val = (float)(xkb_info->xkb->ctrls->repeat_interval - 5) /
 416               (float)(MAX_REPEAT_RATE * 1000);
 417     else
 418         val = 5.0 / (float)(MAX_REPEAT_RATE * 1000);
 419     ScaleJumpCallback(repeatRate->scroller, (XtPointer)repeatRate,
 420                       (XtPointer)&val);
 421     if (xkb_info->xkb->ctrls->repeat_delay > 5)
 422         val = (float)(xkb_info->xkb->ctrls->repeat_delay - 5) /
 423               (float)(MAX_REPEAT_DELAY * 1000);
 424     else
 425         val = 5.0 / (float)(MAX_REPEAT_DELAY * 1000);
 426     ScaleJumpCallback(repeatDelay->scroller, (XtPointer)repeatDelay,
 427                       (XtPointer)&val);
 428
 429     XtSetArg(args[0], XtNstate, &state);
 430     XtGetValues(slowToggle, args, 1);
 431     EnableCallback(slowToggle, (XtPointer)slowForm, (XtPointer)(long)state);
 432     if (xkb_info->xkb->ctrls->slow_keys_delay > 10)
 433         val = (float)(xkb_info->xkb->ctrls->repeat_delay - 10) /
 434               (float)(MAX_SLOW_TIME * 1000);
 435     else
 436         val = 10.0 / (float)(MAX_SLOW_TIME * 1000);
 437     ScaleJumpCallback(slow->scroller, (XtPointer)slow, (XtPointer)&val);
 438
 439     XtSetArg(args[0], XtNstate, &state);
 440     XtGetValues(bounceToggle, args, 1);
 441     EnableCallback(bounceToggle, (XtPointer)bounceForm, (XtPointer)(long)state);
 442     if (xkb_info->xkb->ctrls->debounce_delay > 10)
 443         val = (float)(xkb_info->xkb->ctrls->debounce_delay - 10) /
 444               (float)(MAX_BOUNCE_TIME * 1000);
 445     else
 446         val = 10.0 / (float)(MAX_BOUNCE_TIME * 1000);
 447     ScaleJumpCallback(bounce->scroller, (XtPointer)bounce, (XtPointer)&val);
 448
 449     XtSetArg(args[0], XtNstate, &state);
 450     XtGetValues(enable, args, 1);
 451 }
 452
 453 void
 454 AccessXConfigureStart(void)
 455 {
 456     AccessXInitialize();
 457
 458     XtMapWidget(accessx);
 459 }
 460
 461 void
 462 AccessXConfigureEnd(void)
 463 {
 464     XtUnmapWidget(accessx);
 465 }
 466
 467 /*ARGSUSED*/
 468 static void
 469 EnableCallback(Widget w, XtPointer user_data, XtPointer call_data)
 470 {
 471     XtSetSensitive((Widget)user_data, (long)call_data);
 472 }
 473
 474 /*ARGSUSED*/
 475 static void
 476 ScaleEnableCallback(Widget w, XtPointer user_data, XtPointer call_data)
 477 {
 478     Scale *scale = (Scale*)user_data;
 479
 480     XtSetSensitive(scale->label, (long)call_data);
 481     XtSetSensitive(scale->number, (long)call_data);
 482     XtSetSensitive(scale->scroller, (long)call_data);
 483 }
 484
 485 static void
 486 ScaleJumpCallback(Widget w, XtPointer user_data, XtPointer call_data)
 487 {
 488     Scale *scale = (Scale*)user_data;
 489     float percent = *(float *)call_data, timeout = percent * scale->max;
 490     int x;
 491     char str[8];
 492     Arg args[1];
 493
 494     if (timeout >= scale->max - scale->min)
 495         timeout = scale->max - scale->min;
 496
 497     if (scale->integer) {
 498         int tm = timeout + scale->min;
 499
 500         tm -= tm % (int)scale->resolution;
 501         XmuSnprintf(str, sizeof(str), "%i", tm);
 502         scale->value = tm;
 503     }
 504     else {
 505         long tm = (timeout + scale->min) * 1e+6;
 506
 507         tm -= tm % (long)(scale->resolution * 1e+6);
 508         scale->value = (double)tm / 1e+6;
 509         XmuSnprintf(str, sizeof(str), "%f", scale->value);
 510     }
 511
 512     XtSetArg(args[0], XtNlabel, str);
 513     XtSetValues(scale->number, args, 1);
 514     x = w->core.x + w->core.border_width;
 515     x += ((double)(w->core.width - scale->number->core.width) / scale->max) * timeout;
 516     XtMoveWidget(scale->number, x, scale->number->core.y);
 517     XawScrollbarSetThumb(w, timeout / (scale->max - scale->min),
 518                          scale->resolution / (scale->max - scale->min));
 519 }
 520
 521 /*ARGSUSED*/
 522 static void
 523 ApplyCallback(Widget w, XtPointer user_data, XtPointer call_data)
 524 {
 525     Arg args[1];
 526     Boolean state;
 527
 528     XkbGetControls(DPY, XkbAllControlsMask, xkb_info->xkb);
 529
 530     /* Enable AccessX */
 531     XtSetArg(args[0], XtNstate, &state);
 532     XtGetValues(enable, args, 1);
 533     if (state) {
 534         xkb_info->config.initial_ctrls |= XkbAccessXKeysMask;
 535         xkb_info->xkb->ctrls->enabled_ctrls |= XkbAccessXKeysMask;
 536     }
 537     else {
 538         xkb_info->config.initial_ctrls &= ~XkbAccessXKeysMask;
 539         xkb_info->xkb->ctrls->enabled_ctrls &= ~XkbAccessXKeysMask;
 540     }
 541
 542     /* Timeout */
 543     XtSetArg(args[0], XtNstate, &state);
 544     XtGetValues(timeoutToggle, args, 1);
 545     if (state)
 546         xkb_info->config.ax_timeout =
 547         xkb_info->xkb->ctrls->ax_timeout = timeout->value * 60;
 548     else
 549         xkb_info->config.ax_timeout =
 550         xkb_info->xkb->ctrls->ax_timeout = 65535;
 551
 552     /* Enable StickyKeys */
 553     XtSetArg(args[0], XtNstate, &state);
 554     XtGetValues(sticky, args, 1);
 555     if (state) {
 556         xkb_info->config.initial_ctrls |= XkbStickyKeysMask;
 557         xkb_info->xkb->ctrls->enabled_ctrls |= XkbStickyKeysMask;
 558     }
 559     else {
 560         xkb_info->config.initial_ctrls &= ~XkbStickyKeysMask;
 561         xkb_info->xkb->ctrls->enabled_ctrls &= ~XkbStickyKeysMask;
 562     }
 563     XtSetArg(args[0], XtNstate, &state);
 564     XtGetValues(stickyAuto, args, 1);
 565     if (state) {
 566         xkb_info->config.initial_opts &= ~XkbAX_TwoKeysMask;
 567         xkb_info->config.initial_opts &= ~XkbAX_LatchToLockMask;
 568         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_TwoKeysMask;
 569         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_LatchToLockMask;
 570     }
 571     else {
 572         xkb_info->config.initial_opts &= ~XkbAX_TwoKeysMask;
 573         xkb_info->config.initial_opts |= XkbAX_LatchToLockMask;
 574         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_TwoKeysMask;
 575         xkb_info->xkb->ctrls->ax_options |= XkbAX_LatchToLockMask;
 576     }
 577     XtSetArg(args[0], XtNstate, &state);
 578     XtGetValues(stickyBeep, args, 1);
 579     if (state) {
 580         xkb_info->config.initial_opts |= XkbAX_StickyKeysFBMask;
 581         xkb_info->xkb->ctrls->ax_options |= XkbAX_StickyKeysFBMask;
 582     }
 583     else {
 584         xkb_info->config.initial_opts &= ~XkbAX_StickyKeysFBMask;
 585         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_StickyKeysFBMask;
 586     }
 587
 588     /* Enable MouseKeys */
 589     XtSetArg(args[0], XtNstate, &state);
 590     XtGetValues(mouse, args, 1);
 591     if (state) {
 592         xkb_info->config.initial_ctrls |= XkbMouseKeysAccelMask;
 593         xkb_info->xkb->ctrls->enabled_ctrls |= XkbMouseKeysMask |
 594                                                XkbMouseKeysAccelMask;
 595         xkb_info->config.mk_delay =
 596             xkb_info->xkb->ctrls->mk_delay = mouseDelay->value * 100;
 597         xkb_info->config.mk_interval =
 598             xkb_info->xkb->ctrls->mk_interval = 40;
 599         xkb_info->config.mk_time_to_max =
 600         xkb_info->xkb->ctrls->mk_time_to_max =
 601             (mouseTime->value * 1000) / xkb_info->xkb->ctrls->mk_interval;
 602         xkb_info->config.mk_max_speed =
 603         xkb_info->xkb->ctrls->mk_max_speed =
 604             mouseSpeed->value * mouseTime->value;
 605         xkb_info->config.mk_curve = xkb_info->xkb->ctrls->mk_curve = 0;
 606     }
 607     else {
 608         xkb_info->config.initial_ctrls &= ~(XkbMouseKeysMask |
 609                                             XkbMouseKeysAccelMask);
 610         xkb_info->xkb->ctrls->enabled_ctrls &= ~(XkbMouseKeysMask |
 611                                                  XkbMouseKeysAccelMask);
 612     }
 613
 614     /* Enable RepeatKeys */
 615     XtSetArg(args[0], XtNstate, &state);
 616     XtGetValues(repeat, args, 1);
 617     if (state) {
 618         xkb_info->config.initial_ctrls |= XkbRepeatKeysMask;
 619         xkb_info->xkb->ctrls->enabled_ctrls |= XkbRepeatKeysMask;
 620         xkb_info->config.repeat_interval =
 621         xkb_info->xkb->ctrls->repeat_interval = repeatRate->value * 1000;
 622         xkb_info->config.repeat_delay =
 623         xkb_info->xkb->ctrls->repeat_delay = repeatDelay->value * 1000;
 624     }
 625     else {
 626         xkb_info->config.initial_ctrls &= ~XkbRepeatKeysMask;
 627         xkb_info->xkb->ctrls->enabled_ctrls &= ~XkbRepeatKeysMask;
 628     }
 629
 630     /* Enable SlowKeys */
 631     XtSetArg(args[0], XtNstate, &state);
 632     XtGetValues(slowToggle, args, 1);
 633     if (state) {
 634         xkb_info->config.initial_ctrls |= XkbSlowKeysMask;
 635         xkb_info->xkb->ctrls->enabled_ctrls |= XkbSlowKeysMask;
 636         xkb_info->config.slow_keys_delay =
 637         xkb_info->xkb->ctrls->slow_keys_delay = slow->value * 1000;
 638     }
 639     else {
 640         xkb_info->config.initial_ctrls &= ~XkbSlowKeysMask;
 641         xkb_info->xkb->ctrls->enabled_ctrls &= ~XkbSlowKeysMask;
 642     }
 643     XtSetArg(args[0], XtNstate, &state);
 644     XtGetValues(slowPressed, args, 1);
 645     if (state) {
 646         xkb_info->config.initial_opts |= XkbAX_SKPressFBMask;
 647         xkb_info->xkb->ctrls->ax_options |= XkbAX_SKPressFBMask;
 648     }
 649     else {
 650         xkb_info->config.initial_opts &= ~XkbAX_SKPressFBMask;
 651         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_SKPressFBMask;
 652     }
 653     XtSetArg(args[0], XtNstate, &state);
 654     XtGetValues(slowAccepted, args, 1);
 655     if (state) {
 656         xkb_info->config.initial_opts |= XkbAX_SKAcceptFBMask;
 657         xkb_info->xkb->ctrls->ax_options |= XkbAX_SKAcceptFBMask;
 658     }
 659     else {
 660         xkb_info->config.initial_opts &= ~XkbAX_SKAcceptFBMask;
 661         xkb_info->xkb->ctrls->ax_options &= ~XkbAX_SKAcceptFBMask;
 662     }
 663
 664     /* Enable BounceKeys */
 665     XtSetArg(args[0], XtNstate, &state);
 666     XtGetValues(bounceToggle, args, 1);
 667     if (state) {
 668         xkb_info->config.initial_ctrls |= XkbBounceKeysMask;
 669         xkb_info->xkb->ctrls->enabled_ctrls |= XkbBounceKeysMask;
 670         xkb_info->config.debounce_delay =
 671         xkb_info->xkb->ctrls->debounce_delay = bounce->value * 1000;
 672     }
 673     else {
 674         xkb_info->config.initial_ctrls &= ~XkbBounceKeysMask;
 675         xkb_info->xkb->ctrls->enabled_ctrls &= ~XkbBounceKeysMask;
 676     }
 677
 678     XkbSetControls(DPY, XkbAllControlsMask, xkb_info->xkb);
 679     XSync(DPY, False);
 680     (void)UpdateKeyboard(True);
 681 }