1 /************************************************************
2 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
4 Permission to use, copy, modify, and distribute this
5 software and its documentation for any purpose and without
6 fee is hereby granted, provided that the above copyright
7 notice appear in all copies and that both that copyright
8 notice and this permission notice appear in supporting
9 documentation, and that the name of Silicon Graphics not be
10 used in advertising or publicity pertaining to distribution
11 of the software without specific prior written permission.
12 Silicon Graphics makes no representation about the suitability
13 of this software for any purpose. It is provided "as is"
14 without any express or implied warranty.
16 SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18 AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19 GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22 OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23 THE USE OR PERFORMANCE OF THIS SOFTWARE.
25 ********************************************************/
27 #ifdef HAVE_DIX_CONFIG_H
28 #include <dix-config.h>
31 #include <xkb-config.h>
39 #include <X11/Xproto.h>
40 #include <X11/keysym.h>
41 #include <X11/Xatom.h>
46 #include "scrnintstr.h"
47 #define XKBSRV_NEED_FILE_FUNCS
50 #include <X11/extensions/XKMformat.h>
54 #define CREATE_ATOM(s) MakeAtom(s,sizeof(s)-1,1)
56 #if defined(__alpha) || defined(__alpha__)
61 #define PHYS_LEDS 0x1f
68 #define PHYS_LEDS 0x0f
73 #define PHYS_LEDS 0x07
78 typedef struct _SrvXkmInfo
{
84 /***====================================================================***/
86 #ifndef XKB_DFLT_RULES_PROP
87 #define XKB_DFLT_RULES_PROP TRUE
90 const char *XkbBaseDirectory
= XKB_BASE_DIRECTORY
;
91 const char *XkbBinDirectory
= XKB_BIN_DIRECTORY
;
92 static int XkbWantAccessX
= 0;
94 static char *XkbRulesDflt
= NULL
;
95 static char *XkbModelDflt
= NULL
;
96 static char *XkbLayoutDflt
= NULL
;
97 static char *XkbVariantDflt
= NULL
;
98 static char *XkbOptionsDflt
= NULL
;
100 static char *XkbRulesUsed
= NULL
;
101 static char *XkbModelUsed
= NULL
;
102 static char *XkbLayoutUsed
= NULL
;
103 static char *XkbVariantUsed
= NULL
;
104 static char *XkbOptionsUsed
= NULL
;
106 static XkbDescPtr xkb_cached_map
= NULL
;
108 static Bool XkbWantRulesProp
= XKB_DFLT_RULES_PROP
;
110 /***====================================================================***/
113 * Get the current default XKB rules.
114 * Caller must free the data in rmlvo.
117 XkbGetRulesDflts(XkbRMLVOSet
* rmlvo
)
119 rmlvo
->rules
= strdup(XkbRulesDflt
? XkbRulesDflt
: XKB_DFLT_RULES
);
120 rmlvo
->model
= strdup(XkbModelDflt
? XkbModelDflt
: XKB_DFLT_MODEL
);
121 rmlvo
->layout
= strdup(XkbLayoutDflt
? XkbLayoutDflt
: XKB_DFLT_LAYOUT
);
122 rmlvo
->variant
= strdup(XkbVariantDflt
? XkbVariantDflt
: XKB_DFLT_VARIANT
);
123 rmlvo
->options
= strdup(XkbOptionsDflt
? XkbOptionsDflt
: XKB_DFLT_OPTIONS
);
127 XkbFreeRMLVOSet(XkbRMLVOSet
* rmlvo
, Bool freeRMLVO
)
135 free(rmlvo
->variant
);
136 free(rmlvo
->options
);
141 memset(rmlvo
, 0, sizeof(XkbRMLVOSet
));
145 XkbWriteRulesProp(ClientPtr client
, pointer closure
)
151 len
= (XkbRulesUsed
? strlen(XkbRulesUsed
) : 0);
152 len
+= (XkbModelUsed
? strlen(XkbModelUsed
) : 0);
153 len
+= (XkbLayoutUsed
? strlen(XkbLayoutUsed
) : 0);
154 len
+= (XkbVariantUsed
? strlen(XkbVariantUsed
) : 0);
155 len
+= (XkbOptionsUsed
? strlen(XkbOptionsUsed
) : 0);
159 len
+= 5; /* trailing NULs */
162 MakeAtom(_XKB_RF_NAMES_PROP_ATOM
, strlen(_XKB_RF_NAMES_PROP_ATOM
), 1);
164 ErrorF("[xkb] Atom error: %s not created\n", _XKB_RF_NAMES_PROP_ATOM
);
167 pval
= (char *) malloc(len
);
169 ErrorF("[xkb] Allocation error: %s proprerty not created\n",
170 _XKB_RF_NAMES_PROP_ATOM
);
175 strcpy(&pval
[out
], XkbRulesUsed
);
176 out
+= strlen(XkbRulesUsed
);
180 strcpy(&pval
[out
], XkbModelUsed
);
181 out
+= strlen(XkbModelUsed
);
185 strcpy(&pval
[out
], XkbLayoutUsed
);
186 out
+= strlen(XkbLayoutUsed
);
189 if (XkbVariantUsed
) {
190 strcpy(&pval
[out
], XkbVariantUsed
);
191 out
+= strlen(XkbVariantUsed
);
194 if (XkbOptionsUsed
) {
195 strcpy(&pval
[out
], XkbOptionsUsed
);
196 out
+= strlen(XkbOptionsUsed
);
200 ErrorF("[xkb] Internal Error! bad size (%d!=%d) for _XKB_RULES_NAMES\n",
203 dixChangeWindowProperty(serverClient
, screenInfo
.screens
[0]->root
, name
,
204 XA_STRING
, 8, PropModeReplace
, len
, pval
, TRUE
);
210 XkbSetRulesUsed(XkbRMLVOSet
* rmlvo
)
213 XkbRulesUsed
= (rmlvo
->rules
? Xstrdup(rmlvo
->rules
) : NULL
);
215 XkbModelUsed
= (rmlvo
->model
? Xstrdup(rmlvo
->model
) : NULL
);
217 XkbLayoutUsed
= (rmlvo
->layout
? Xstrdup(rmlvo
->layout
) : NULL
);
218 free(XkbVariantUsed
);
219 XkbVariantUsed
= (rmlvo
->variant
? Xstrdup(rmlvo
->variant
) : NULL
);
220 free(XkbOptionsUsed
);
221 XkbOptionsUsed
= (rmlvo
->options
? Xstrdup(rmlvo
->options
) : NULL
);
222 if (XkbWantRulesProp
)
223 QueueWorkProc(XkbWriteRulesProp
, NULL
, NULL
);
228 XkbSetRulesDflts(XkbRMLVOSet
* rmlvo
)
232 XkbRulesDflt
= Xstrdup(rmlvo
->rules
);
236 XkbModelDflt
= Xstrdup(rmlvo
->model
);
240 XkbLayoutDflt
= Xstrdup(rmlvo
->layout
);
242 if (rmlvo
->variant
) {
243 free(XkbVariantDflt
);
244 XkbVariantDflt
= Xstrdup(rmlvo
->variant
);
246 if (rmlvo
->options
) {
247 free(XkbOptionsDflt
);
248 XkbOptionsDflt
= Xstrdup(rmlvo
->options
);
254 XkbDeleteRulesUsed(void)
261 XkbLayoutUsed
= NULL
;
262 free(XkbVariantUsed
);
263 XkbVariantUsed
= NULL
;
264 free(XkbOptionsUsed
);
265 XkbOptionsUsed
= NULL
;
269 XkbDeleteRulesDflts(void)
276 XkbLayoutDflt
= NULL
;
277 free(XkbVariantDflt
);
278 XkbVariantDflt
= NULL
;
279 free(XkbOptionsDflt
);
280 XkbOptionsDflt
= NULL
;
282 XkbFreeKeyboard(xkb_cached_map
, XkbAllComponentsMask
, TRUE
);
283 xkb_cached_map
= NULL
;
286 #define DIFFERS(a, b) (strcmp((a) ? (a) : "", (b) ? (b) : "") != 0)
289 XkbCompareUsedRMLVO(XkbRMLVOSet
* rmlvo
)
291 if (DIFFERS(rmlvo
->rules
, XkbRulesUsed
) ||
292 DIFFERS(rmlvo
->model
, XkbModelUsed
) ||
293 DIFFERS(rmlvo
->layout
, XkbLayoutUsed
) ||
294 DIFFERS(rmlvo
->variant
, XkbVariantUsed
) ||
295 DIFFERS(rmlvo
->options
, XkbOptionsUsed
))
302 /***====================================================================***/
304 #include "xkbDflts.h"
307 XkbInitKeyTypes(XkbDescPtr xkb
)
309 if (xkb
->defined
& XkmTypesMask
)
313 if (XkbAllocClientMap(xkb
, XkbKeyTypesMask
, num_dflt_types
) != Success
)
315 if (XkbCopyKeyTypes(dflt_types
, xkb
->map
->types
, num_dflt_types
) != Success
) {
318 xkb
->map
->size_types
= xkb
->map
->num_types
= num_dflt_types
;
323 XkbInitRadioGroups(XkbSrvInfoPtr xkbi
)
325 xkbi
->nRadioGroups
= 0;
326 xkbi
->radioGroups
= NULL
;
331 XkbInitCompatStructs(XkbDescPtr xkb
)
334 XkbCompatMapPtr compat
;
336 if (xkb
->defined
& XkmCompatMapMask
)
339 if (XkbAllocCompatMap(xkb
, XkbAllCompatMask
, num_dfltSI
) != Success
)
341 compat
= xkb
->compat
;
342 if (compat
->sym_interpret
) {
343 compat
->num_si
= num_dfltSI
;
344 memcpy((char *) compat
->sym_interpret
, (char *) dfltSI
, sizeof(dfltSI
));
346 for (i
= 0; i
< XkbNumKbdGroups
; i
++) {
347 compat
->groups
[i
] = compatMap
.groups
[i
];
348 if (compat
->groups
[i
].vmods
!= 0) {
351 mask
= XkbMaskForVMask(xkb
, compat
->groups
[i
].vmods
);
352 compat
->groups
[i
].mask
= compat
->groups
[i
].real_mods
| mask
;
355 compat
->groups
[i
].mask
= compat
->groups
[i
].real_mods
;
361 XkbInitSemantics(XkbDescPtr xkb
)
363 XkbInitKeyTypes(xkb
);
364 XkbInitCompatStructs(xkb
);
368 /***====================================================================***/
371 XkbInitNames(XkbSrvInfoPtr xkbi
)
379 if ((rtrn
= XkbAllocNames(xkb
, XkbAllNamesMask
, 0, 0)) != Success
)
381 unknown
= CREATE_ATOM("unknown");
383 if (names
->keycodes
== None
)
384 names
->keycodes
= unknown
;
385 if (names
->geometry
== None
)
386 names
->geometry
= unknown
;
387 if (names
->phys_symbols
== None
)
388 names
->phys_symbols
= unknown
;
389 if (names
->symbols
== None
)
390 names
->symbols
= unknown
;
391 if (names
->types
== None
)
392 names
->types
= unknown
;
393 if (names
->compat
== None
)
394 names
->compat
= unknown
;
395 if (!(xkb
->defined
& XkmVirtualModsMask
)) {
396 if (names
->vmods
[vmod_NumLock
] == None
)
397 names
->vmods
[vmod_NumLock
] = CREATE_ATOM("NumLock");
398 if (names
->vmods
[vmod_Alt
] == None
)
399 names
->vmods
[vmod_Alt
] = CREATE_ATOM("Alt");
400 if (names
->vmods
[vmod_AltGr
] == None
)
401 names
->vmods
[vmod_AltGr
] = CREATE_ATOM("ModeSwitch");
404 if (!(xkb
->defined
& XkmIndicatorsMask
) ||
405 !(xkb
->defined
& XkmGeometryMask
)) {
406 initIndicatorNames(NULL
, xkb
);
407 if (names
->indicators
[LED_CAPS
- 1] == None
)
408 names
->indicators
[LED_CAPS
- 1] = CREATE_ATOM("Caps Lock");
409 if (names
->indicators
[LED_NUM
- 1] == None
)
410 names
->indicators
[LED_NUM
- 1] = CREATE_ATOM("Num Lock");
411 if (names
->indicators
[LED_SCROLL
- 1] == None
)
412 names
->indicators
[LED_SCROLL
- 1] = CREATE_ATOM("Scroll Lock");
414 if (names
->indicators
[LED_COMPOSE
- 1] == None
)
415 names
->indicators
[LED_COMPOSE
- 1] = CREATE_ATOM("Compose");
419 if (xkb
->geom
!= NULL
)
420 names
->geometry
= xkb
->geom
->name
;
422 names
->geometry
= unknown
;
428 XkbInitIndicatorMap(XkbSrvInfoPtr xkbi
)
432 XkbSrvLedInfoPtr sli
;
435 if (XkbAllocIndicatorMaps(xkb
) != Success
)
438 if (!(xkb
->defined
& XkmIndicatorsMask
)) {
439 map
= xkb
->indicators
;
440 map
->phys_indicators
= PHYS_LEDS
;
441 map
->maps
[LED_CAPS
- 1].flags
= XkbIM_NoExplicit
;
442 map
->maps
[LED_CAPS
- 1].which_mods
= XkbIM_UseLocked
;
443 map
->maps
[LED_CAPS
- 1].mods
.mask
= LockMask
;
444 map
->maps
[LED_CAPS
- 1].mods
.real_mods
= LockMask
;
446 map
->maps
[LED_NUM
- 1].flags
= XkbIM_NoExplicit
;
447 map
->maps
[LED_NUM
- 1].which_mods
= XkbIM_UseLocked
;
448 map
->maps
[LED_NUM
- 1].mods
.mask
= 0;
449 map
->maps
[LED_NUM
- 1].mods
.real_mods
= 0;
450 map
->maps
[LED_NUM
- 1].mods
.vmods
= vmod_NumLockMask
;
452 map
->maps
[LED_SCROLL
- 1].flags
= XkbIM_NoExplicit
;
453 map
->maps
[LED_SCROLL
- 1].which_mods
= XkbIM_UseLocked
;
454 map
->maps
[LED_SCROLL
- 1].mods
.mask
= Mod3Mask
;
455 map
->maps
[LED_SCROLL
- 1].mods
.real_mods
= Mod3Mask
;
458 sli
= XkbFindSrvLedInfo(xkbi
->device
, XkbDfltXIClass
, XkbDfltXIId
, 0);
460 XkbCheckIndicatorMaps(xkbi
->device
, sli
, XkbAllIndicatorsMask
);
466 XkbInitControls(DeviceIntPtr pXDev
, XkbSrvInfoPtr xkbi
)
469 XkbControlsPtr ctrls
;
472 /* 12/31/94 (ef) -- XXX! Should check if controls loaded from file */
473 if (XkbAllocControls(xkb
, XkbAllControlsMask
) != Success
)
474 FatalError("Couldn't allocate keyboard controls\n");
476 if (!(xkb
->defined
& XkmSymbolsMask
))
477 ctrls
->num_groups
= 1;
478 ctrls
->groups_wrap
= XkbSetGroupInfo(1, XkbWrapIntoRange
, 0);
479 ctrls
->internal
.mask
= 0;
480 ctrls
->internal
.real_mods
= 0;
481 ctrls
->internal
.vmods
= 0;
482 ctrls
->ignore_lock
.mask
= 0;
483 ctrls
->ignore_lock
.real_mods
= 0;
484 ctrls
->ignore_lock
.vmods
= 0;
485 ctrls
->enabled_ctrls
= XkbAccessXTimeoutMask
| XkbRepeatKeysMask
|
486 XkbMouseKeysAccelMask
| XkbAudibleBellMask
| XkbIgnoreGroupLockMask
;
488 ctrls
->enabled_ctrls
|= XkbAccessXKeysMask
;
494 InitKeyboardDeviceStruct(DeviceIntPtr dev
, XkbRMLVOSet
* rmlvo
,
495 BellProcPtr bell_func
, KbdCtrlProcPtr ctrl_func
)
501 XkbSrvLedInfoPtr sli
;
502 XkbChangesRec changes
;
503 XkbEventCauseRec cause
;
504 XkbRMLVOSet rmlvo_dflts
= { NULL
};
506 BUG_RETURN_VAL(dev
== NULL
, FALSE
);
507 BUG_RETURN_VAL(dev
->key
!= NULL
, FALSE
);
508 BUG_RETURN_VAL(dev
->kbdfeed
!= NULL
, FALSE
);
511 rmlvo
= &rmlvo_dflts
;
512 XkbGetRulesDflts(rmlvo
);
515 memset(&changes
, 0, sizeof(changes
));
516 XkbSetCauseUnknown(&cause
);
518 dev
->key
= calloc(1, sizeof(*dev
->key
));
520 ErrorF("XKB: Failed to allocate key class\n");
523 dev
->key
->sourceid
= dev
->id
;
525 dev
->kbdfeed
= calloc(1, sizeof(*dev
->kbdfeed
));
527 ErrorF("XKB: Failed to allocate key feedback class\n");
531 xkbi
= calloc(1, sizeof(*xkbi
));
533 ErrorF("XKB: Failed to allocate XKB info\n");
536 dev
->key
->xkbInfo
= xkbi
;
538 if (xkb_cached_map
&& !XkbCompareUsedRMLVO(rmlvo
)) {
539 XkbFreeKeyboard(xkb_cached_map
, XkbAllComponentsMask
, TRUE
);
540 xkb_cached_map
= NULL
;
544 LogMessageVerb(X_INFO
, 4, "XKB: Reusing cached keymap\n");
546 xkb_cached_map
= XkbCompileKeymap(dev
, rmlvo
);
547 if (!xkb_cached_map
) {
548 ErrorF("XKB: Failed to compile keymap\n");
553 xkb
= XkbAllocKeyboard();
555 ErrorF("XKB: Failed to allocate keyboard description\n");
559 if (!XkbCopyKeymap(xkb
, xkb_cached_map
)) {
560 ErrorF("XKB: Failed to copy keymap\n");
563 xkb
->defined
= xkb_cached_map
->defined
;
564 xkb
->flags
= xkb_cached_map
->flags
;
565 xkb
->device_spec
= xkb_cached_map
->device_spec
;
568 if (xkb
->min_key_code
== 0)
569 xkb
->min_key_code
= 8;
570 if (xkb
->max_key_code
== 0)
571 xkb
->max_key_code
= 255;
573 i
= XkbNumKeys(xkb
) / 3 + 1;
574 if (XkbAllocClientMap(xkb
, XkbAllClientInfoMask
, 0) != Success
)
576 if (XkbAllocServerMap(xkb
, XkbAllServerInfoMask
, i
) != Success
)
579 xkbi
->dfltPtrDelta
= 1;
582 XkbInitSemantics(xkb
);
584 XkbInitRadioGroups(xkbi
);
586 XkbInitControls(dev
, xkbi
);
588 XkbInitIndicatorMap(xkbi
);
590 XkbUpdateActions(dev
, xkb
->min_key_code
, XkbNumKeys(xkb
), &changes
,
594 InitFocusClassDeviceStruct(dev
);
596 xkbi
->kbdProc
= ctrl_func
;
597 dev
->kbdfeed
->BellProc
= bell_func
;
598 dev
->kbdfeed
->CtrlProc
= XkbDDXKeybdCtrlProc
;
600 dev
->kbdfeed
->ctrl
= defaultKeyboardControl
;
601 if (dev
->kbdfeed
->ctrl
.autoRepeat
)
602 xkb
->ctrls
->enabled_ctrls
|= XkbRepeatKeysMask
;
604 memcpy(dev
->kbdfeed
->ctrl
.autoRepeats
, xkb
->ctrls
->per_key_repeat
,
605 XkbPerKeyBitArraySize
);
607 sli
= XkbFindSrvLedInfo(dev
, XkbDfltXIClass
, XkbDfltXIId
, 0);
609 XkbCheckIndicatorMaps(dev
, sli
, XkbAllIndicatorsMask
);
611 DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
613 dev
->kbdfeed
->CtrlProc(dev
, &dev
->kbdfeed
->ctrl
);
615 XkbSetRulesDflts(rmlvo
);
616 XkbSetRulesUsed(rmlvo
);
617 XkbFreeRMLVOSet(&rmlvo_dflts
, FALSE
);
622 XkbFreeKeyboard(xkb
, 0, TRUE
);
625 dev
->key
->xkbInfo
= NULL
;
635 /***====================================================================***/
638 * Be very careful about what does and doesn't get freed by this
639 * function. To reduce fragmentation, XkbInitDevice allocates a
640 * single huge block per device and divides it up into most of the
641 * fixed-size structures for the device. Don't free anything that
642 * is part of this larger block.
645 XkbFreeInfo(XkbSrvInfoPtr xkbi
)
647 free(xkbi
->radioGroups
);
648 xkbi
->radioGroups
= NULL
;
649 if (xkbi
->mouseKeyTimer
) {
650 TimerFree(xkbi
->mouseKeyTimer
);
651 xkbi
->mouseKeyTimer
= NULL
;
653 if (xkbi
->slowKeysTimer
) {
654 TimerFree(xkbi
->slowKeysTimer
);
655 xkbi
->slowKeysTimer
= NULL
;
657 if (xkbi
->bounceKeysTimer
) {
658 TimerFree(xkbi
->bounceKeysTimer
);
659 xkbi
->bounceKeysTimer
= NULL
;
661 if (xkbi
->repeatKeyTimer
) {
662 TimerFree(xkbi
->repeatKeyTimer
);
663 xkbi
->repeatKeyTimer
= NULL
;
665 if (xkbi
->krgTimer
) {
666 TimerFree(xkbi
->krgTimer
);
667 xkbi
->krgTimer
= NULL
;
669 xkbi
->beepType
= _BEEP_NONE
;
670 if (xkbi
->beepTimer
) {
671 TimerFree(xkbi
->beepTimer
);
672 xkbi
->beepTimer
= NULL
;
675 XkbFreeKeyboard(xkbi
->desc
, XkbAllComponentsMask
, TRUE
);
682 /***====================================================================***/
684 extern int XkbDfltRepeatDelay
;
685 extern int XkbDfltRepeatInterval
;
687 extern unsigned short XkbDfltAccessXTimeout
;
688 extern unsigned int XkbDfltAccessXTimeoutMask
;
689 extern unsigned int XkbDfltAccessXFeedback
;
690 extern unsigned char XkbDfltAccessXOptions
;
693 XkbProcessArguments(int argc
, char *argv
[], int i
)
695 if (strncmp(argv
[i
], "-xkbdir", 7) == 0) {
697 #if !defined(WIN32) && !defined(__CYGWIN__)
698 if (getuid() != geteuid()) {
699 LogMessage(X_WARNING
,
700 "-xkbdir is not available for setuid X servers\n");
706 if (strlen(argv
[i
]) < PATH_MAX
) {
707 XkbBaseDirectory
= argv
[i
];
711 LogMessage(X_ERROR
, "-xkbdir pathname too long\n");
720 else if ((strncmp(argv
[i
], "-accessx", 8) == 0) ||
721 (strncmp(argv
[i
], "+accessx", 8) == 0)) {
724 if (argv
[i
][0] == '-')
729 if (((i
+ 1) < argc
) && (isdigit(argv
[i
+ 1][0]))) {
730 XkbDfltAccessXTimeout
= atoi(argv
[++i
]);
733 if (((i
+ 1) < argc
) && (isdigit(argv
[i
+ 1][0]))) {
735 * presumption that the reasonably useful range of
736 * values fits in 0..MAXINT since SunOS 4 doesn't
739 XkbDfltAccessXTimeoutMask
= (unsigned int)
740 strtol(argv
[++i
], NULL
, 16);
743 if (((i
+ 1) < argc
) && (isdigit(argv
[i
+ 1][0]))) {
744 if (argv
[++i
][0] == '1')
745 XkbDfltAccessXFeedback
= XkbAccessXFeedbackMask
;
747 XkbDfltAccessXFeedback
= 0;
750 if (((i
+ 1) < argc
) && (isdigit(argv
[i
+ 1][0]))) {
751 XkbDfltAccessXOptions
= (unsigned char)
752 strtol(argv
[++i
], NULL
, 16);
759 if ((strcmp(argv
[i
], "-ardelay") == 0) || (strcmp(argv
[i
], "-ar1") == 0)) { /* -ardelay int */
763 XkbDfltRepeatDelay
= (long) atoi(argv
[i
]);
766 if ((strcmp(argv
[i
], "-arinterval") == 0) || (strcmp(argv
[i
], "-ar2") == 0)) { /* -arinterval int */
770 XkbDfltRepeatInterval
= (long) atoi(argv
[i
]);
780 ("[+-]accessx [ timeout [ timeout_mask [ feedback [ options_mask] ] ] ]\n");
781 ErrorF(" enable/disable accessx key sequences\n");
782 ErrorF("-ardelay set XKB autorepeat delay\n");
783 ErrorF("-arinterval set XKB autorepeat interval\n");