← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/vnc4/gutsy

« back to all changes in this revision

Viewing changes to unix/xc/programs/Xserver/xkb/xkbDflts.h

  • Committer: Bazaar Package Importer
  • Author(s): Ola Lundqvist
  • Date: 2006-05-15 20:35:17 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20060515203517-l4lre1ku942mn26k
Tags: 4.1.1+X4.3.0-10
* Correction of critical security issue. Thanks to Martin Kogler
  <e9925248@student.tuwien.ac.at> that informed me about the issue,
  and provided the patch.
  This flaw was originally found by Steve Wiseman of intelliadmin.com.
* Applied patch from Javier Kohen <jkohen@users.sourceforge.net> that
  inform the user that only 8 first characters of the password will
  actually be used when typing more than 8 characters, closes:
  #355619.

Show diffs side-by-side

added added

removed removed

Lines of Context:
unix/xc/programs/Xserver/xkb/xkbDflts.h
 
1
/* $Xorg: xkbDflts.h,v 1.3 2000/08/17 19:53:47 cpqbld Exp $ */
 
2
/* $XFree86: xc/programs/Xserver/xkb/xkbDflts.h,v 1.2 2001/10/28 03:34:20 tsi Exp $ */
 
3
/* This file generated automatically by xkbcomp */
 
4
/* DO  NOT EDIT */
 
5
#ifndef DEFAULT_H
 
6
#define DEFAULT_H 1
 
7
 
 
8
#ifndef XKB_IN_SERVER
 
9
#define GET_ATOM(d,s)   XInternAtom(d,s,0)
 
10
#define DPYTYPE Display *
 
11
#else
 
12
#define GET_ATOM(d,s)   MakeAtom(s,strlen(s),1)
 
13
#define DPYTYPE char *
 
14
#endif
 
15
#define NUM_KEYS        1
 
16
 
 
17
#define vmod_NumLock    0
 
18
#define vmod_Alt        1
 
19
#define vmod_LevelThree 2
 
20
#define vmod_AltGr      3
 
21
#define vmod_ScrollLock 4
 
22
 
 
23
#define vmod_NumLockMask        (1<<0)
 
24
#define vmod_AltMask    (1<<1)
 
25
#define vmod_LevelThreeMask     (1<<2)
 
26
#define vmod_AltGrMask  (1<<3)
 
27
#define vmod_ScrollLockMask     (1<<4)
 
28
 
 
29
/* types name is "default" */
 
30
static Atom lnames_ONE_LEVEL[1];
 
31
 
 
32
static XkbKTMapEntryRec map_TWO_LEVEL[1]= {
 
33
    { 1,      1, {       ShiftMask,       ShiftMask,               0 } }
 
34
};
 
35
static Atom lnames_TWO_LEVEL[2];
 
36
 
 
37
static XkbKTMapEntryRec map_ALPHABETIC[2]= {
 
38
    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
 
39
    { 1,      0, {        LockMask,        LockMask,               0 } }
 
40
};
 
41
static XkbModsRec preserve_ALPHABETIC[2]= {
 
42
    {                 0,               0,               0 },
 
43
    {          LockMask,        LockMask,               0 }
 
44
};
 
45
static Atom lnames_ALPHABETIC[2];
 
46
 
 
47
static XkbKTMapEntryRec map_KEYPAD[2]= {
 
48
    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
 
49
    { 0,      1, {               0,               0, vmod_NumLockMask } }
 
50
};
 
51
static Atom lnames_KEYPAD[2];
 
52
 
 
53
static XkbKTMapEntryRec map_PC_BREAK[1]= {
 
54
    { 1,      1, {     ControlMask,     ControlMask,               0 } }
 
55
};
 
56
static Atom lnames_PC_BREAK[2];
 
57
 
 
58
static XkbKTMapEntryRec map_PC_SYSRQ[1]= {
 
59
    { 0,      1, {               0,               0,    vmod_AltMask } }
 
60
};
 
61
static Atom lnames_PC_SYSRQ[2];
 
62
 
 
63
static XkbKTMapEntryRec map_CTRL_ALT[1]= {
 
64
    { 0,      1, {     ControlMask,     ControlMask,    vmod_AltMask } }
 
65
};
 
66
static Atom lnames_CTRL_ALT[2];
 
67
 
 
68
static XkbKTMapEntryRec map_THREE_LEVEL[3]= {
 
69
    { 1,      1, {       ShiftMask,       ShiftMask,               0 } },
 
70
    { 0,      2, {               0,               0, vmod_LevelThreeMask } },
 
71
    { 0,      2, {       ShiftMask,       ShiftMask, vmod_LevelThreeMask } }
 
72
};
 
73
static Atom lnames_THREE_LEVEL[3];
 
74
 
 
75
static XkbKTMapEntryRec map_SHIFT_ALT[1]= {
 
76
    { 0,      1, {       ShiftMask,       ShiftMask,    vmod_AltMask } }
 
77
};
 
78
static Atom lnames_SHIFT_ALT[2];
 
79
 
 
80
static XkbKeyTypeRec dflt_types[]= {
 
81
    {
 
82
        {               0,               0,               0 },
 
83
        1,
 
84
        0,      NULL,   NULL,
 
85
        None,   lnames_ONE_LEVEL
 
86
    },
 
87
    {
 
88
        {       ShiftMask,       ShiftMask,               0 },
 
89
        2,
 
90
        1,      map_TWO_LEVEL,  NULL,
 
91
        None,   lnames_TWO_LEVEL
 
92
    },
 
93
    {
 
94
        { ShiftMask|LockMask, ShiftMask|LockMask,               0 },
 
95
        2,
 
96
        2,      map_ALPHABETIC, preserve_ALPHABETIC,
 
97
        None,   lnames_ALPHABETIC
 
98
    },
 
99
    {
 
100
        {       ShiftMask,       ShiftMask, vmod_NumLockMask },
 
101
        2,
 
102
        2,      map_KEYPAD,     NULL,
 
103
        None,   lnames_KEYPAD
 
104
    },
 
105
    {
 
106
        {     ControlMask,     ControlMask,               0 },
 
107
        2,
 
108
        1,      map_PC_BREAK,   NULL,
 
109
        None,   lnames_PC_BREAK
 
110
    },
 
111
    {
 
112
        {               0,               0,    vmod_AltMask },
 
113
        2,
 
114
        1,      map_PC_SYSRQ,   NULL,
 
115
        None,   lnames_PC_SYSRQ
 
116
    },
 
117
    {
 
118
        {     ControlMask,     ControlMask,    vmod_AltMask },
 
119
        2,
 
120
        1,      map_CTRL_ALT,   NULL,
 
121
        None,   lnames_CTRL_ALT
 
122
    },
 
123
    {
 
124
        {       ShiftMask,       ShiftMask, vmod_LevelThreeMask },
 
125
        3,
 
126
        3,      map_THREE_LEVEL,        NULL,
 
127
        None,   lnames_THREE_LEVEL
 
128
    },
 
129
    {
 
130
        {       ShiftMask,       ShiftMask,    vmod_AltMask },
 
131
        2,
 
132
        1,      map_SHIFT_ALT,  NULL,
 
133
        None,   lnames_SHIFT_ALT
 
134
    }
 
135
};
 
136
#define num_dflt_types (sizeof(dflt_types)/sizeof(XkbKeyTypeRec))
 
137
 
 
138
 
 
139
static void
 
140
#if NeedFunctionPrototypes
 
141
initTypeNames(DPYTYPE dpy)
 
142
#else
 
143
initTypeNames(dpy)
 
144
DPYTYPE dpy;
 
145
#endif
 
146
{
 
147
    dflt_types[0].name= GET_ATOM(dpy,"ONE_LEVEL");
 
148
    lnames_ONE_LEVEL[0]=        GET_ATOM(dpy,"Any");
 
149
    dflt_types[1].name= GET_ATOM(dpy,"TWO_LEVEL");
 
150
    lnames_TWO_LEVEL[0]=        GET_ATOM(dpy,"Base");
 
151
    lnames_TWO_LEVEL[1]=        GET_ATOM(dpy,"Shift");
 
152
    dflt_types[2].name= GET_ATOM(dpy,"ALPHABETIC");
 
153
    lnames_ALPHABETIC[0]=       GET_ATOM(dpy,"Base");
 
154
    lnames_ALPHABETIC[1]=       GET_ATOM(dpy,"Caps");
 
155
    dflt_types[3].name= GET_ATOM(dpy,"KEYPAD");
 
156
    lnames_KEYPAD[0]=   GET_ATOM(dpy,"Base");
 
157
    lnames_KEYPAD[1]=   GET_ATOM(dpy,"Number");
 
158
    dflt_types[4].name= GET_ATOM(dpy,"PC_BREAK");
 
159
    lnames_PC_BREAK[0]= GET_ATOM(dpy,"Base");
 
160
    lnames_PC_BREAK[1]= GET_ATOM(dpy,"Control");
 
161
    dflt_types[5].name= GET_ATOM(dpy,"PC_SYSRQ");
 
162
    lnames_PC_SYSRQ[0]= GET_ATOM(dpy,"Base");
 
163
    lnames_PC_SYSRQ[1]= GET_ATOM(dpy,"Alt");
 
164
    dflt_types[6].name= GET_ATOM(dpy,"CTRL+ALT");
 
165
    lnames_CTRL_ALT[0]= GET_ATOM(dpy,"Base");
 
166
    lnames_CTRL_ALT[1]= GET_ATOM(dpy,"Ctrl+Alt");
 
167
    dflt_types[7].name= GET_ATOM(dpy,"THREE_LEVEL");
 
168
    lnames_THREE_LEVEL[0]=      GET_ATOM(dpy,"Base");
 
169
    lnames_THREE_LEVEL[1]=      GET_ATOM(dpy,"Shift");
 
170
    lnames_THREE_LEVEL[2]=      GET_ATOM(dpy,"Level3");
 
171
    dflt_types[8].name= GET_ATOM(dpy,"SHIFT+ALT");
 
172
    lnames_SHIFT_ALT[0]=        GET_ATOM(dpy,"Base");
 
173
    lnames_SHIFT_ALT[1]=        GET_ATOM(dpy,"Shift+Alt");
 
174
}
 
175
/* compat name is "default" */
 
176
static XkbSymInterpretRec dfltSI[69]= {
 
177
    {    XK_ISO_Level2_Latch, 0x0000,
 
178
         XkbSI_LevelOneOnly|XkbSI_Exactly, ShiftMask,
 
179
         255,
 
180
       {      XkbSA_LatchMods, { 0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
181
    {    XK_Eisu_Shift, 0x0000,
 
182
         XkbSI_Exactly, LockMask,
 
183
         255,
 
184
       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
185
    {    XK_Eisu_toggle, 0x0000,
 
186
         XkbSI_Exactly, LockMask,
 
187
         255,
 
188
       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
189
    {    XK_Kana_Shift, 0x0000,
 
190
         XkbSI_Exactly, LockMask,
 
191
         255,
 
192
       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
193
    {    XK_Kana_Lock, 0x0000,
 
194
         XkbSI_Exactly, LockMask,
 
195
         255,
 
196
       {       XkbSA_NoAction, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
197
    {    XK_Shift_Lock, 0x0000,
 
198
         XkbSI_AnyOf, ShiftMask|LockMask,
 
199
         255,
 
200
       {       XkbSA_LockMods, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
201
    {    XK_Num_Lock, 0x0000,
 
202
         XkbSI_AnyOf, 0xff,
 
203
         0,
 
204
       {       XkbSA_LockMods, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
 
205
    {    XK_Alt_L, 0x0000,
 
206
         XkbSI_AnyOf, 0xff,
 
207
         1,
 
208
       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
209
    {    XK_Alt_R, 0x0000,
 
210
         XkbSI_AnyOf, 0xff,
 
211
         1,
 
212
       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
213
    {    XK_Scroll_Lock, 0x0000,
 
214
         XkbSI_AnyOf, 0xff,
 
215
         4,
 
216
       {       XkbSA_LockMods, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
217
    {    XK_ISO_Lock, 0x0000,
 
218
         XkbSI_AnyOf, 0xff,
 
219
         255,
 
220
       {        XkbSA_ISOLock, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
221
    {    XK_ISO_Level3_Shift, 0x0000,
 
222
         XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
 
223
         2,
 
224
       {        XkbSA_SetMods, { 0x01, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
 
225
    {    XK_ISO_Level3_Latch, 0x0000,
 
226
         XkbSI_LevelOneOnly|XkbSI_AnyOf, 0xff,
 
227
         2,
 
228
       {      XkbSA_LatchMods, { 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00 } } },
 
229
    {    XK_Mode_switch, 0x0000,
 
230
         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
 
231
         3,
 
232
       {       XkbSA_SetGroup, { 0x05, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
233
    {    XK_KP_1, 0x0001,
 
234
         XkbSI_AnyOfOrNone, 0xff,
 
235
         255,
 
236
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
 
237
    {    XK_KP_End, 0x0001,
 
238
         XkbSI_AnyOfOrNone, 0xff,
 
239
         255,
 
240
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x01, 0x00, 0x00 } } },
 
241
    {    XK_KP_2, 0x0001,
 
242
         XkbSI_AnyOfOrNone, 0xff,
 
243
         255,
 
244
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
 
245
    {    XK_KP_Down, 0x0001,
 
246
         XkbSI_AnyOfOrNone, 0xff,
 
247
         255,
 
248
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00 } } },
 
249
    {    XK_KP_3, 0x0001,
 
250
         XkbSI_AnyOfOrNone, 0xff,
 
251
         255,
 
252
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
 
253
    {    XK_KP_Next, 0x0001,
 
254
         XkbSI_AnyOfOrNone, 0xff,
 
255
         255,
 
256
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00 } } },
 
257
    {    XK_KP_4, 0x0001,
 
258
         XkbSI_AnyOfOrNone, 0xff,
 
259
         255,
 
260
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
 
261
    {    XK_KP_Left, 0x0001,
 
262
         XkbSI_AnyOfOrNone, 0xff,
 
263
         255,
 
264
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
 
265
    {    XK_KP_6, 0x0001,
 
266
         XkbSI_AnyOfOrNone, 0xff,
 
267
         255,
 
268
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
269
    {    XK_KP_Right, 0x0001,
 
270
         XkbSI_AnyOfOrNone, 0xff,
 
271
         255,
 
272
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
273
    {    XK_KP_7, 0x0001,
 
274
         XkbSI_AnyOfOrNone, 0xff,
 
275
         255,
 
276
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
 
277
    {    XK_KP_Home, 0x0001,
 
278
         XkbSI_AnyOfOrNone, 0xff,
 
279
         255,
 
280
       {        XkbSA_MovePtr, { 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 } } },
 
281
    {    XK_KP_8, 0x0001,
 
282
         XkbSI_AnyOfOrNone, 0xff,
 
283
         255,
 
284
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
 
285
    {    XK_KP_Up, 0x0001,
 
286
         XkbSI_AnyOfOrNone, 0xff,
 
287
         255,
 
288
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
 
289
    {    XK_KP_9, 0x0001,
 
290
         XkbSI_AnyOfOrNone, 0xff,
 
291
         255,
 
292
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00 } } },
 
293
    {    XK_KP_Prior, 0x0001,
 
294
         XkbSI_AnyOfOrNone, 0xff,
 
295
         255,
 
296
       {        XkbSA_MovePtr, { 0x00, 0x00, 0x01, 0xff, 0xff, 0x00, 0x00 } } },
 
297
    {    XK_KP_5, 0x0001,
 
298
         XkbSI_AnyOfOrNone, 0xff,
 
299
         255,
 
300
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
301
    {    XK_KP_Begin, 0x0001,
 
302
         XkbSI_AnyOfOrNone, 0xff,
 
303
         255,
 
304
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
305
    {    XK_KP_F1, 0x0001,
 
306
         XkbSI_AnyOfOrNone, 0xff,
 
307
         255,
 
308
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
309
    {    XK_KP_Divide, 0x0001,
 
310
         XkbSI_AnyOfOrNone, 0xff,
 
311
         255,
 
312
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
313
    {    XK_KP_F2, 0x0001,
 
314
         XkbSI_AnyOfOrNone, 0xff,
 
315
         255,
 
316
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
317
    {    XK_KP_Multiply, 0x0001,
 
318
         XkbSI_AnyOfOrNone, 0xff,
 
319
         255,
 
320
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
321
    {    XK_KP_F3, 0x0001,
 
322
         XkbSI_AnyOfOrNone, 0xff,
 
323
         255,
 
324
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
 
325
    {    XK_KP_Subtract, 0x0001,
 
326
         XkbSI_AnyOfOrNone, 0xff,
 
327
         255,
 
328
       {     XkbSA_SetPtrDflt, { 0x04, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
 
329
    {    XK_KP_Separator, 0x0001,
 
330
         XkbSI_AnyOfOrNone, 0xff,
 
331
         255,
 
332
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
333
    {    XK_KP_Add, 0x0001,
 
334
         XkbSI_AnyOfOrNone, 0xff,
 
335
         255,
 
336
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
337
    {    XK_KP_0, 0x0001,
 
338
         XkbSI_AnyOfOrNone, 0xff,
 
339
         255,
 
340
       {     XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
341
    {    XK_KP_Insert, 0x0001,
 
342
         XkbSI_AnyOfOrNone, 0xff,
 
343
         255,
 
344
       {     XkbSA_LockPtrBtn, { 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
345
    {    XK_KP_Decimal, 0x0001,
 
346
         XkbSI_AnyOfOrNone, 0xff,
 
347
         255,
 
348
       {     XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
349
    {    XK_KP_Delete, 0x0001,
 
350
         XkbSI_AnyOfOrNone, 0xff,
 
351
         255,
 
352
       {     XkbSA_LockPtrBtn, { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
353
    {    XK_Pointer_Button_Dflt, 0x0000,
 
354
         XkbSI_AnyOfOrNone, 0xff,
 
355
         255,
 
356
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
357
    {    XK_Pointer_Button1, 0x0000,
 
358
         XkbSI_AnyOfOrNone, 0xff,
 
359
         255,
 
360
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
361
    {    XK_Pointer_Button2, 0x0000,
 
362
         XkbSI_AnyOfOrNone, 0xff,
 
363
         255,
 
364
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
365
    {    XK_Pointer_Button3, 0x0000,
 
366
         XkbSI_AnyOfOrNone, 0xff,
 
367
         255,
 
368
       {         XkbSA_PtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
 
369
    {    XK_Pointer_DblClick_Dflt, 0x0000,
 
370
         XkbSI_AnyOfOrNone, 0xff,
 
371
         255,
 
372
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
373
    {    XK_Pointer_DblClick1, 0x0000,
 
374
         XkbSI_AnyOfOrNone, 0xff,
 
375
         255,
 
376
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
377
    {    XK_Pointer_DblClick2, 0x0000,
 
378
         XkbSI_AnyOfOrNone, 0xff,
 
379
         255,
 
380
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
381
    {    XK_Pointer_DblClick3, 0x0000,
 
382
         XkbSI_AnyOfOrNone, 0xff,
 
383
         255,
 
384
       {         XkbSA_PtrBtn, { 0x00, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
 
385
    {    XK_Pointer_Drag_Dflt, 0x0000,
 
386
         XkbSI_AnyOfOrNone, 0xff,
 
387
         255,
 
388
       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
389
    {    XK_Pointer_Drag1, 0x0000,
 
390
         XkbSI_AnyOfOrNone, 0xff,
 
391
         255,
 
392
       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
393
    {    XK_Pointer_Drag2, 0x0000,
 
394
         XkbSI_AnyOfOrNone, 0xff,
 
395
         255,
 
396
       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
397
    {    XK_Pointer_Drag3, 0x0000,
 
398
         XkbSI_AnyOfOrNone, 0xff,
 
399
         255,
 
400
       {     XkbSA_LockPtrBtn, { 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00 } } },
 
401
    {    XK_Pointer_EnableKeys, 0x0000,
 
402
         XkbSI_AnyOfOrNone, 0xff,
 
403
         255,
 
404
       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00 } } },
 
405
    {    XK_Pointer_Accelerate, 0x0000,
 
406
         XkbSI_AnyOfOrNone, 0xff,
 
407
         255,
 
408
       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00 } } },
 
409
    {    XK_Pointer_DfltBtnNext, 0x0000,
 
410
         XkbSI_AnyOfOrNone, 0xff,
 
411
         255,
 
412
       {     XkbSA_SetPtrDflt, { 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00 } } },
 
413
    {    XK_Pointer_DfltBtnPrev, 0x0000,
 
414
         XkbSI_AnyOfOrNone, 0xff,
 
415
         255,
 
416
       {     XkbSA_SetPtrDflt, { 0x00, 0x01, 0xff, 0x00, 0x00, 0x00, 0x00 } } },
 
417
    {    XK_AccessX_Enable, 0x0000,
 
418
         XkbSI_AnyOfOrNone, 0xff,
 
419
         255,
 
420
       {   XkbSA_LockControls, { 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00 } } },
 
421
    {    XK_Terminate_Server, 0x0000,
 
422
         XkbSI_AnyOfOrNone, 0xff,
 
423
         255,
 
424
       {      XkbSA_Terminate, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
425
    {    XK_ISO_Group_Latch, 0x0000,
 
426
         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
 
427
         3,
 
428
       {     XkbSA_LatchGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
429
    {    XK_ISO_Next_Group, 0x0000,
 
430
         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
 
431
         3,
 
432
       {      XkbSA_LockGroup, { 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
433
    {    XK_ISO_Prev_Group, 0x0000,
 
434
         XkbSI_LevelOneOnly|XkbSI_AnyOfOrNone, 0xff,
 
435
         3,
 
436
       {      XkbSA_LockGroup, { 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
437
    {    XK_ISO_First_Group, 0x0000,
 
438
         XkbSI_AnyOfOrNone, 0xff,
 
439
         255,
 
440
       {      XkbSA_LockGroup, { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
441
    {    XK_ISO_Last_Group, 0x0000,
 
442
         XkbSI_AnyOfOrNone, 0xff,
 
443
         255,
 
444
       {      XkbSA_LockGroup, { 0x04, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00 } } },
 
445
    {    NoSymbol, 0x0000,
 
446
         XkbSI_Exactly, LockMask,
 
447
         255,
 
448
       {       XkbSA_LockMods, { 0x00, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00 } } },
 
449
    {    NoSymbol, 0x0000,
 
450
         XkbSI_AnyOf, 0xff,
 
451
         255,
 
452
       {        XkbSA_SetMods, { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } } }
 
453
};
 
454
#define num_dfltSI (sizeof(dfltSI)/sizeof(XkbSymInterpretRec))
 
455
 
 
456
static XkbCompatMapRec compatMap= {
 
457
    dfltSI,
 
458
    {   /* group compatibility */
 
459
        {            0,            0,            0 },
 
460
        {            0,            0, vmod_AltGrMask },
 
461
        {            0,            0, vmod_AltGrMask },
 
462
        {            0,            0, vmod_AltGrMask }
 
463
    },
 
464
    num_dfltSI, num_dfltSI
 
465
};
 
466
 
 
467
static XkbIndicatorRec indicators= {
 
468
    0x0,
 
469
    {
 
470
        { 0x80, 0, 0x00, XkbIM_UseEffective, { LockMask,  LockMask, 0 }, 0 },
 
471
        { 0x80, 0, 0x00, XkbIM_UseEffective, { 0,  0, vmod_NumLockMask }, 0 },
 
472
        { 0x80, 0, 0x00, XkbIM_UseLocked, { ShiftMask,  ShiftMask, 0 }, 0 },
 
473
        { 0x80, 0, 0x00, 0, { 0,  0, 0 }, XkbMouseKeysMask },
 
474
        { 0x80, 0, 0x00, XkbIM_UseLocked, { 0,  0, vmod_ScrollLockMask }, 0 },
 
475
        { 0x80, XkbIM_UseEffective, 0xfe, 0, { 0,  0, 0 }, 0 },
 
476
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
477
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
478
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
479
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
480
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
481
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
482
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
483
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
484
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
485
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
486
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
487
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
488
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
489
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
490
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
491
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
492
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
493
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
494
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
495
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
496
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
497
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
498
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
499
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
500
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 },
 
501
        { 0x00, 0, 0x00, 0, { 0,  0, 0 }, 0 }
 
502
    }
 
503
};
 
504
static void
 
505
#if NeedFunctionPrototypes
 
506
initIndicatorNames(DPYTYPE dpy,XkbDescPtr xkb)
 
507
#else
 
508
initIndicatorNames(dpy,xkb)
 
509
    DPYTYPE dpy;
 
510
    XkbDescPtr xkb;
 
511
#endif
 
512
{
 
513
    xkb->names->indicators[ 0]= GET_ATOM(dpy,"Caps Lock");
 
514
    xkb->names->indicators[ 1]= GET_ATOM(dpy,"Num Lock");
 
515
    xkb->names->indicators[ 2]= GET_ATOM(dpy,"Shift Lock");
 
516
    xkb->names->indicators[ 3]= GET_ATOM(dpy,"Mouse Keys");
 
517
    xkb->names->indicators[ 4]= GET_ATOM(dpy,"Scroll Lock");
 
518
    xkb->names->indicators[ 5]= GET_ATOM(dpy,"Group 2");
 
519
}
 
520
#endif /* DEFAULT_H */