summaryrefslogtreecommitdiffstats
path: root/macosx/tkMacOSXKeyboard.c
blob: 8a3caa22684674be723bfecd4bdd474a12451617 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
/* 
 * tkMacOSXKeyboard.c --
 *
 *      Routines to support keyboard events on the Macintosh.
 *
 * Copyright (c) 1995-1997 Sun Microsystems, Inc.
 * Copyright 2001, Apple Computer, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tkMacOSXKeyboard.c,v 1.11 2003/12/15 18:48:07 cc_benny Exp $
 */

#include "tkInt.h"
#include "X11/Xlib.h"
#include "X11/keysym.h"
#include <Carbon/Carbon.h>
#include "tkMacOSXInt.h"
#include "tkMacOSXEvent.h"      /* TkMacOSXKeycodeToUnicode() FIXME: That
                                 * function should probably move here. */

/*
 * A couple of simple definitions to make code a bit more self-explaining.
 *
 * For the assignments of Mod1==alt==command and Mod2==meta==option, see also
 * tkMacOSXMouseEvent.c.
 */

#define LATIN1_MAX       255
#define MAC_KEYCODE_MAX  0x7F
#define MAC_KEYCODE_MASK 0x7F
#define ALT_MASK         Mod1Mask
#define OPTION_MASK      Mod2Mask


/*
 * Tables enumerating the special keys defined on Mac keyboards.  These are
 * necessary for correct keysym mappings for all keys where the keysyms are
 * not identical with their ASCII or Latin-1 code points.
 */

typedef struct {
    int keycode;                /* Macintosh keycode. */
    KeySym keysym;              /* X windows keysym. */
} KeyInfo;

/*
 * Notes on keyArray:
 *
 * 0x34, XK_Return - Powerbooks use this and some keymaps define it.
 *
 * 0x4C, XK_Return - XFree86 and Apple's X11 call this one XK_KP_Enter.
 *
 * 0x47, XK_Clear - This key is NumLock when used on PCs, but Mac
 * applications don't use it like that, nor does Apple's X11.
 *
 * All other keycodes are taken from the published ADB keyboard layouts.
 */

static KeyInfo keyArray[] = {
    {0x24,      XK_Return},
    {0x30,      XK_Tab},
    {0x33,      XK_BackSpace},
    {0x34,      XK_Return},
    {0x35,      XK_Escape},

    {0x47,      XK_Clear},
    {0x4C,      XK_Return},

    {0x72,      XK_Help},
    {0x73,      XK_Home},
    {0x74,      XK_Page_Up},
    {0x75,      XK_Delete},
    {0x77,      XK_End},
    {0x79,      XK_Page_Down},

    {0x7B,      XK_Left},
    {0x7C,      XK_Right},
    {0x7D,      XK_Down},
    {0x7E,      XK_Up},

    {0,         0}
};

static KeyInfo virtualkeyArray[] = {
    {122,       XK_F1},
    {120,       XK_F2},
    {99,        XK_F3},
    {118,       XK_F4},
    {96,        XK_F5},
    {97,        XK_F6},
    {98,        XK_F7},
    {100,       XK_F8},
    {101,       XK_F9},
    {109,       XK_F10},
    {103,       XK_F11},
    {111,       XK_F12},
    {105,       XK_F13},
    {107,       XK_F14},
    {113,       XK_F15},
    {0,         0}
};

static int initialized = 0;
static Tcl_HashTable keycodeTable;      /* keyArray hashed by keycode value. */
static Tcl_HashTable vkeyTable;         /* virtualkeyArray hashed by virtual
                                         * keycode value. */

static int latin1Table[LATIN1_MAX+1];   /* Reverse mapping table for
                                         * controls, ASCII and Latin-1.  */

/*
 * Prototypes for static functions used in this file.
 */

static void     InitKeyMaps (void);
static void     InitLatin1Table(Display *display);
static int      XKeysymToMacKeycode(Display *display, KeySym keysym);


/*
 *----------------------------------------------------------------------
 *
 * InitKeyMaps --
 *
 *      Creates hash tables used by some of the functions in this file.
 *
 *      FIXME: As keycodes are defined to be in the limited range 0-127, it
 *      would be easier and more efficient to use directly initialized plain
 *      arrays and drop this function.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Allocates memory & creates some hash tables.
 *
 *----------------------------------------------------------------------
 */

static void
InitKeyMaps()
{
    Tcl_HashEntry *hPtr;
    KeyInfo *kPtr;
    int dummy;
                
    Tcl_InitHashTable(&keycodeTable, TCL_ONE_WORD_KEYS);
    for (kPtr = keyArray; kPtr->keycode != 0; kPtr++) {
        hPtr = Tcl_CreateHashEntry(&keycodeTable, (char *) kPtr->keycode,
                &dummy);
        Tcl_SetHashValue(hPtr, kPtr->keysym);
    }
    Tcl_InitHashTable(&vkeyTable, TCL_ONE_WORD_KEYS);
    for (kPtr = virtualkeyArray; kPtr->keycode != 0; kPtr++) {
        hPtr = Tcl_CreateHashEntry(&vkeyTable, (char *) kPtr->keycode,
                &dummy);
        Tcl_SetHashValue(hPtr, kPtr->keysym);
    }
    initialized = 1;
}

/*
 *----------------------------------------------------------------------
 *
 * InitLatin1Table --
 *
 *      Creates a simple table to be used for mapping from keysyms to
 *      keycodes.  Always needs to be called before using latin1Table,
 *      because the keyboard layout may have changed, and than the table must
 *      be re-computed.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Sets the global latin1Table.
 *
 *----------------------------------------------------------------------
 */

static void
InitLatin1Table(
    Display *display)
{
    static Boolean latin1_initialized = false;
    static SInt16 lastKeyLayoutID = -1;

    SInt16 keyScript;
    SInt16 keyLayoutID;

    keyScript = GetScriptManagerVariable(smKeyScript);
    keyLayoutID = GetScriptVariable(keyScript,smScriptKeys);

    if (!latin1_initialized || (lastKeyLayoutID != keyLayoutID)) {
        int keycode;
        KeySym keysym;
        int state;
        int modifiers;

        latin1_initialized = true;
        lastKeyLayoutID = keyLayoutID;

        memset(latin1Table, 0, sizeof(latin1Table));
        
        /*
         * In the common X11 implementations, a keymap has four columns
         * "plain", "Shift", "Mode_switch" and "Mode_switch + Shift".  We
         * don't use "Mode_switch", but we use "Option" instead.  (This is
         * similar to Apple's X11 implementation, where "Mode_switch" is used
         * as an alias for "Option".)
         *
         * So here we go through all 4 columns of the keymap and find all
         * Latin-1 compatible keycodes.  We go through the columns
         * back-to-front from the more exotic columns to the more simple, so
         * that simple keycode-modifier combinations are preferred in the
         * resulting table.
         */

        for (state = 3; state >= 0; state--) {
            modifiers = 0;
            if (state & 1) {
                modifiers |= shiftKey;
            }
            if (state & 2) {
                modifiers |= optionKey;
            }

            for (keycode = 0; keycode <= MAC_KEYCODE_MAX; keycode++) {
                keysym = XKeycodeToKeysym(display,keycode<<16,state);
                if (keysym <= LATIN1_MAX) {
                    latin1Table[keysym] = keycode | modifiers;
                }
            }
        }
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XKeycodeToKeysym --
 *
 *      Translate from a system-dependent keycode to a system-independent
 *      keysym.
 *
 * Results:
 *      Returns the translated keysym, or NoSymbol on failure.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

KeySym 
XKeycodeToKeysym(
    Display* display,
    KeyCode keycode,
    int index)
{
    register Tcl_HashEntry *hPtr;
    int newKeycode;
    UniChar newChar;

    (void) display; /*unused*/

    if (!initialized) {
        InitKeyMaps();
    }

    /*
     * When determining what keysym to produce we first check to see if the
     * key is a function key.  We then check to see if the character is
     * another non-printing key.  Finally, we return the key syms for all
     * ASCII and Latin-1 chars.
     */

    newKeycode = keycode >> 16;

    if ((keycode & 0xFFFF) == 0x10) {
        hPtr = Tcl_FindHashEntry(&vkeyTable, (char *) newKeycode);
        if (hPtr != NULL) {
            return (KeySym) Tcl_GetHashValue(hPtr);
        }
    }
    hPtr = Tcl_FindHashEntry(&keycodeTable, (char *) newKeycode);
    if (hPtr != NULL) {
        return (KeySym) Tcl_GetHashValue(hPtr);
    }

    /* 
     * Add in the Mac modifier flags for shift and option.
     */

    if (index & 1) {
        newKeycode |= shiftKey;
    }
    if (index & 2) {
        newKeycode |= optionKey;
    }

    newChar = 0;
    TkMacOSXKeycodeToUnicode(
        &newChar, 1, kEventRawKeyDown,
        newKeycode & 0x00FF, newKeycode & 0xFF00, NULL);

    /*
     * X11 keysyms are identical to Unicode for ASCII and Latin-1.  Give up
     * for other characters for now.
     */

    if ((newChar >= XK_space) && (newChar <= LATIN1_MAX)) {
        return newChar;
    }

    return NoSymbol; 
}

/*
 *----------------------------------------------------------------------
 *
 * TkpGetString --
 *
 *      Retrieve the string equivalent for the given keyboard event.
 *
 * Results:
 *      Returns the UTF string.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
TkpGetString(
    TkWindow *winPtr,           /* Window where event occurred: Needed to get
                                 * input context. */
    XEvent *eventPtr,           /* X keyboard event. */
    Tcl_DString *dsPtr)         /* Uninitialized or empty string to hold
                                 * result. */
{
    (void) winPtr; /*unused*/
    Tcl_DStringInit(dsPtr);
    return Tcl_DStringAppend(dsPtr, eventPtr->xkey.trans_chars, -1);
}

/*
 *----------------------------------------------------------------------
 *
 * XGetModifierMapping --
 *
 *      Fetch the current keycodes used as modifiers.
 *
 * Results:
 *      Returns a new modifier map.
 *
 * Side effects:
 *      Allocates a new modifier map data structure.
 *
 *----------------------------------------------------------------------
 */

XModifierKeymap * 
XGetModifierMapping(
    Display* display)
{ 
    XModifierKeymap * modmap;

    (void) display; /*unused*/

    /*
     * MacOSX doesn't use the key codes for the modifiers for anything, and
     * we don't generate them either.  So there is no modifier map.
     */

    modmap = (XModifierKeymap *) ckalloc(sizeof(XModifierKeymap));
    modmap->max_keypermod = 0;
    modmap->modifiermap = NULL;
    return modmap;
}

/*
 *----------------------------------------------------------------------
 *
 * XFreeModifiermap --
 *
 *      Deallocate a modifier map that was created by XGetModifierMapping.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Frees the datastructure referenced by modmap.
 *
 *----------------------------------------------------------------------
 */

void 
XFreeModifiermap(
    XModifierKeymap *modmap)
{
    if (modmap->modifiermap != NULL) {
        ckfree((char *) modmap->modifiermap);
    }
    ckfree((char *) modmap);
}

/*
 *----------------------------------------------------------------------
 *
 * XKeysymToString, XStringToKeysym --
 *
 *      These X window functions map keysyms to strings & strings to keysyms.
 *      However, Tk already does this for the most common keysyms.
 *      Therefore, these functions only need to support keysyms that will be
 *      specific to the Macintosh.  Currently, there are none.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char * 
XKeysymToString(
    KeySym keysym)
{
    return NULL; 
}

KeySym 
XStringToKeysym(
    const char* string)
{ 
    return NoSymbol;
}

/*
 *----------------------------------------------------------------------
 *
 * XKeysymToMacKeycode --
 *
 *      An internal function like XKeysymToKeycode but only generating the
 *      Mac specific keycode plus the modifiers Shift and Option.
 *
 * Results:
 *      A Mac keycode with the actual keycode in the low byte and Mac-style
 *      modifier bits in the high byte.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

static int
XKeysymToMacKeycode(
    Display *display,
    KeySym keysym)
{
    if (keysym <= LATIN1_MAX) {

        /*
         * Handle keysyms in the Latin-1 range where keysym and Unicode
         * character code point are the same.
         */

        InitLatin1Table(display);
        return latin1Table[keysym];

    } else {

        /*
         * Handle special keys from our exception tables.  Don't mind if this
         * is slow, neither the test suite nor [event generate] need to be
         * optimized (we hope).
         */

        KeyInfo *kPtr;
                
        for (kPtr = keyArray; kPtr->keycode != 0; kPtr++) {
            if (kPtr->keysym == keysym) {
                return kPtr->keycode;
            }
        }
        for (kPtr = virtualkeyArray; kPtr->keycode != 0; kPtr++) {
            if (kPtr->keysym == keysym) {
                return kPtr->keycode;
            }
        }

        /*
         * For other keysyms (not Latin-1 and not special keys), we'd need a
         * generic keysym-to-unicode table.  We don't have that, so we give
         * up here.
         */

        return 0;
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XKeysymToKeycode --
 *
 *      The function XKeysymToKeycode takes an X11 keysym and converts it
 *      into a Mac keycode.  It is in the stubs table for compatibility but
 *      not used anywhere in the core.
 *
 * Results:
 *      A 32 bit keycode with the the mac keycode (without modifiers) in the
 *      higher 16 bits of the keycode and the ASCII or Latin-1 code in the
 *      lower 8 bits of the keycode.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

KeyCode
XKeysymToKeycode(
    Display* display,
    KeySym keysym)
{
    int macKeycode = XKeysymToMacKeycode(display, keysym);
    KeyCode result;
    
    /*
     * See also TkpSetKeycodeAndState.  The 0x0010 magic is used in
     * XKeycodeToKeysym.  For special keys like XK_Return the lower 8 bits of
     * the keysym are usually a related ASCII control code.
     */

    if ((keysym >= XK_F1) && (keysym <= XK_F35)) {
        result = 0x0010;
    } else {
        result = 0x00FF & keysym;
    }
    result |= (macKeycode & MAC_KEYCODE_MASK) << 16;

    return result;
}

/*
NB: Keep this commented code for a moment for reference.

    if ((keysym >= XK_space) && (XK_asciitilde)) {
        if (keysym == 'a') {
            virtualKeyCode = 0x00;
        } else if (keysym == 'b' || keysym == 'B') {
            virtualKeyCode = 0x0B;
        } else if (keysym == 'c') {
            virtualKeyCode = 0x08;
        } else if (keysym == 'x' || keysym == 'X') {
            virtualKeyCode = 0x07;
        } else if (keysym == 'z') {
            virtualKeyCode = 0x06;
        } else if (keysym == ' ') {
            virtualKeyCode = 0x31;
        } else if (keysym == XK_Return) {
            virtualKeyCode = 0x24;
            keysym = '\r';
        }
        keycode = keysym + (virtualKeyCode <<16);
    }

    return keycode;
*/

/*
 *----------------------------------------------------------------------
 *
 * TkpSetKeycodeAndState --
 *
 *      The function TkpSetKeycodeAndState takes a keysym and fills in the
 *      appropriate members of an XEvent.  It is similar to XKeysymToKeycode,
 *      but it also sets the modifier mask in the XEvent.  It is used by
 *      [event generate] and it is in the stubs table.
 *
 * Results:
 *      Fills an XEvent, sets the member xkey.keycode with a keycode
 *      formatted the same as XKeysymToKeycode and the member xkey.state with
 *      the modifiers implied by the keysym.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

void
TkpSetKeycodeAndState(
    Tk_Window tkwin,
    KeySym keysym,
    XEvent *eventPtr)
{
    if (keysym == NoSymbol) {
        eventPtr->xkey.keycode = 0;
        eventPtr->xkey.state = 0;
    } else {
        Display *display = Tk_Display(tkwin);
        int macKeycode = XKeysymToMacKeycode(display, keysym);

        /*
         * See also XKeysymToKeycode.
         */

        if ((keysym >= XK_F1) && (keysym <= XK_F35)) {
            eventPtr->xkey.keycode = 0x0010;
        } else {
            eventPtr->xkey.keycode = 0x00FF & keysym;
        }
        eventPtr->xkey.keycode |= (macKeycode & MAC_KEYCODE_MASK) << 16;

        eventPtr->xkey.state = 0;
        if (shiftKey & macKeycode) {
            eventPtr->xkey.state |= ShiftMask;
        }
        if (optionKey & macKeycode) {
            eventPtr->xkey.state |= OPTION_MASK;
        }
    }
}

/*
 *----------------------------------------------------------------------
 *
 * TkpGetKeySym --
 *
 *      Given an X KeyPress or KeyRelease event, map the keycode in the event
 *      into a keysym.
 *
 * Results:
 *      The return value is the keysym corresponding to eventPtr, or NoSymbol
 *      if no matching keysym could be found.
 *
 * Side effects:
 *      In the first call for a given display, keycode-to-keysym maps get
 *      loaded.
 *
 *----------------------------------------------------------------------
 */

KeySym
TkpGetKeySym(
    TkDisplay *dispPtr,         /* Display in which to map keycode. */
    XEvent *eventPtr)           /* Description of X event. */
{
    KeySym sym;
    int index;

    /*
     * Refresh the mapping information if it's stale.
     */

    if (dispPtr->bindInfoStale) {
        TkpInitKeymapInfo(dispPtr);
    }

    /*
     * Handle pure modifier keys specially.  We use -1 as a signal for
     * this.
     */

    if (eventPtr->xany.send_event == -1) {
        int modifier = eventPtr->xkey.keycode;
        if (modifier == cmdKey) {
            return XK_Alt_L;
        } else if (modifier == shiftKey) {
            return XK_Shift_L;
        } else if (modifier == alphaLock) {
            return XK_Caps_Lock;
        } else if (modifier == optionKey) {
            return XK_Meta_L;
        } else if (modifier == controlKey) {
            return XK_Control_L;
        } else if (modifier == rightShiftKey) {
            return XK_Shift_R;
        } else if (modifier == rightOptionKey) {
            return XK_Meta_R;
        } else if (modifier == rightControlKey) {
            return XK_Control_R;
        } else {

            /*
             * If we get here, we probably need to implement something new.
             */

            return NoSymbol;
        } 
    }

    /*
     * Figure out which of the four slots in the keymap vector to use for
     * this key.  Refer to Xlib documentation for more info on how this
     * computation works.  (Note: We use "Option" in keymap columns 2 and 3
     * where other implementations have "Mode_switch".)
     */

    index = 0;
    if (eventPtr->xkey.state & OPTION_MASK) {
        index |= 2;
    }
    if ((eventPtr->xkey.state & ShiftMask)
            || (/* (dispPtr->lockUsage != LU_IGNORE)
                   && */ (eventPtr->xkey.state & LockMask))) {
        index |= 1;
    }

    /*
     * First try of the actual translation.
     */

    sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, index);

    /*
     * Special handling: If the key was shifted because of Lock, but lock is
     * only caps lock, not shift lock, and the shifted keysym isn't
     * upper-case alphabetic, then switch back to the unshifted keysym.
     */

    if ((index & 1) && !(eventPtr->xkey.state & ShiftMask)
            /*&& (dispPtr->lockUsage == LU_CAPS)*/ ) {

        /*
         * FIXME: Keysyms are only identical to Unicode for ASCII and
         * Latin-1, so we can't use Tcl_UniCharIsUpper() for keysyms outside
         * that range.  This may be a serious problem here.
         */

        if ((sym == NoSymbol) || (sym > LATIN1_MAX)
                || !Tcl_UniCharIsUpper(sym)) {
            index &= ~1;
            sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode,
                    index);
        }
    }

    /*
     * Another bit of special handling: If this is a shifted key and there is
     * no keysym defined, then use the keysym for the unshifted key.
     */

    if ((index & 1) && (sym == NoSymbol)) {
        sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode,
                index & ~1);
    }
    return sym;
}

/*
 *--------------------------------------------------------------
 *
 * TkpInitKeymapInfo --
 *
 *      This procedure is invoked to scan keymap information to recompute
 *      stuff that's important for binding, such as the modifier key (if any)
 *      that corresponds to the "Mode_switch" keysym.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Keymap-related information in dispPtr is updated.
 *
 *--------------------------------------------------------------
 */

void
TkpInitKeymapInfo(
    TkDisplay *dispPtr)         /* Display for which to recompute keymap
                                 * information. */
{
    dispPtr->bindInfoStale = 0;

    /*
     * Behaviours that are variable on X11 are defined constant on MacOSX.
     * lockUsage is only used above in TkpGetKeySym(), nowhere else
     * currently.  There is no offical "Mode_switch" key.
     */

    dispPtr->lockUsage = LU_CAPS;
    dispPtr->modeModMask = 0;
    dispPtr->altModMask = ALT_MASK;
    dispPtr->metaModMask = OPTION_MASK;

    /*
     * MacOSX doesn't use the keycodes for the modifiers for anything, and we
     * don't generate them either (the keycodes actually given in the
     * simulated modifier events are bogus).  So there is no modifier map.
     * If we ever want to simulate real modifier keycodes, the list will be
     * constant in the Carbon implementation.
     */

    if (dispPtr->modKeyCodes != NULL) {
        ckfree((char *) dispPtr->modKeyCodes);
    }
    dispPtr->numModKeyCodes = 0;
    dispPtr->modKeyCodes = NULL;
}