← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xgl/intrepid

« back to all changes in this revision

Viewing changes to hw/xfree86/utils/xorgcfg/accessx.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthew Garrett
  • Date: 2006-02-13 14:21:43 UTC
  • Revision ID: james.westby@ubuntu.com-20060213142143-mad6z9xzem7hzxz9
Tags: upstream-7.0.0
Import upstream version 7.0.0

Show diffs side-by-side

added added

removed removed

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