Split tangents are now red and merged tangents are yellow.
[synfig.git] / synfig-osx / launcher / darwin-old-keymap.c
1 /* darwin-old-keymap.c -- ugly code we need to keep around for now
2
3    Copyright (c) 2001-2002 Torrey T. Lyons. All Rights Reserved.
4
5    The code to parse the Darwin keymap is derived from dumpkeymap.c
6    by Eric Sunshine, which includes the following copyright:
7
8    Copyright (C) 1999,2000 by Eric Sunshine <sunshine@sunshineco.com>
9    All rights reserved.
10   
11    Redistribution and use in source and binary forms, with or without
12    modification, are permitted provided that the following conditions are met:
13   
14      1. Redistributions of source code must retain the above copyright
15         notice, this list of conditions and the following disclaimer.
16      2. Redistributions in binary form must reproduce the above copyright
17         notice, this list of conditions and the following disclaimer in the
18         documentation and/or other materials provided with the distribution.
19      3. The name of the author may not be used to endorse or promote products
20         derived from this software without specific prior written permission.
21   
22    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
25    NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
27    TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
28    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
32
33 #include "darwin.h"
34 #include "darwin-keyboard.h"
35 #include <errno.h>
36 #include <sys/stat.h>
37 #include <drivers/event_status_driver.h>
38 #include <IOKit/hidsystem/ev_keymap.h>
39 #include <architecture/byte_order.h>  // For the NXSwap*
40
41 #define XK_TECHNICAL            // needed to get XK_Escape
42 #define XK_PUBLISHING
43 #include "keysym.h"
44
45 static  FILE *fref = NULL;
46 static  char *inBuffer = NULL;
47
48 // FIXME: It would be nice to support some of the extra keys in XF86keysym.h,
49 // at least the volume controls that now ship on every Apple keyboard.
50
51 #define UK(a)           NoSymbol        // unknown symbol
52
53 static KeySym const next_to_x[256] = {
54         NoSymbol,       NoSymbol,       NoSymbol,       XK_KP_Enter,
55         NoSymbol,       NoSymbol,       NoSymbol,       NoSymbol,
56         XK_BackSpace,   XK_Tab,         XK_Linefeed,    NoSymbol,
57         NoSymbol,       XK_Return,      NoSymbol,       NoSymbol,
58         NoSymbol,       NoSymbol,       NoSymbol,       NoSymbol,
59         NoSymbol,       NoSymbol,       NoSymbol,       NoSymbol,
60         NoSymbol,       NoSymbol,       NoSymbol,       XK_Escape,
61         NoSymbol,       NoSymbol,       NoSymbol,       NoSymbol,
62         XK_space,       XK_exclam,      XK_quotedbl,    XK_numbersign,
63         XK_dollar,      XK_percent,     XK_ampersand,   XK_apostrophe,
64         XK_parenleft,   XK_parenright,  XK_asterisk,    XK_plus,
65         XK_comma,       XK_minus,       XK_period,      XK_slash,
66         XK_0,           XK_1,           XK_2,           XK_3,
67         XK_4,           XK_5,           XK_6,           XK_7,
68         XK_8,           XK_9,           XK_colon,       XK_semicolon,
69         XK_less,        XK_equal,       XK_greater,     XK_question,
70         XK_at,          XK_A,           XK_B,           XK_C,
71         XK_D,           XK_E,           XK_F,           XK_G,
72         XK_H,           XK_I,           XK_J,           XK_K,
73         XK_L,           XK_M,           XK_N,           XK_O,
74         XK_P,           XK_Q,           XK_R,           XK_S,
75         XK_T,           XK_U,           XK_V,           XK_W,
76         XK_X,           XK_Y,           XK_Z,           XK_bracketleft,
77         XK_backslash,   XK_bracketright,XK_asciicircum, XK_underscore,
78         XK_grave,       XK_a,           XK_b,           XK_c,
79         XK_d,           XK_e,           XK_f,           XK_g,
80         XK_h,           XK_i,           XK_j,           XK_k,
81         XK_l,           XK_m,           XK_n,           XK_o,
82         XK_p,           XK_q,           XK_r,           XK_s,
83         XK_t,           XK_u,           XK_v,           XK_w,
84         XK_x,           XK_y,           XK_z,           XK_braceleft,
85         XK_bar,         XK_braceright,  XK_asciitilde,  XK_BackSpace,
86 // 128
87         NoSymbol,       XK_Agrave,      XK_Aacute,      XK_Acircumflex,
88         XK_Atilde,      XK_Adiaeresis,  XK_Aring,       XK_Ccedilla,
89         XK_Egrave,      XK_Eacute,      XK_Ecircumflex, XK_Ediaeresis,
90         XK_Igrave,      XK_Iacute,      XK_Icircumflex, XK_Idiaeresis,
91 // 144
92         XK_ETH,         XK_Ntilde,      XK_Ograve,      XK_Oacute,
93         XK_Ocircumflex, XK_Otilde,      XK_Odiaeresis,  XK_Ugrave,
94         XK_Uacute,      XK_Ucircumflex, XK_Udiaeresis,  XK_Yacute,
95         XK_THORN,       XK_mu,          XK_multiply,    XK_division,
96 // 160
97         XK_copyright,   XK_exclamdown,  XK_cent,        XK_sterling,
98         UK(fraction),   XK_yen,         UK(fhook),      XK_section,
99         XK_currency,    XK_rightsinglequotemark,
100                                         XK_leftdoublequotemark,
101                                                         XK_guillemotleft,
102         XK_leftanglebracket,
103                         XK_rightanglebracket,
104                                         UK(filigature), UK(flligature),
105 // 176
106         XK_registered,  XK_endash,      XK_dagger,      XK_doubledagger,
107         XK_periodcentered,XK_brokenbar, XK_paragraph,   UK(bullet),
108         XK_singlelowquotemark,
109                         XK_doublelowquotemark,
110                                         XK_rightdoublequotemark,
111                                                         XK_guillemotright,
112         XK_ellipsis,    UK(permille),   XK_notsign,     XK_questiondown,
113 // 192
114         XK_onesuperior, XK_dead_grave,  XK_dead_acute,  XK_dead_circumflex,
115         XK_dead_tilde,  XK_dead_macron, XK_dead_breve,  XK_dead_abovedot,
116         XK_dead_diaeresis,
117                         XK_twosuperior, XK_dead_abovering,
118                                                         XK_dead_cedilla,
119         XK_threesuperior,
120                         XK_dead_doubleacute,
121                                         XK_dead_ogonek, XK_dead_caron,
122 // 208
123         XK_emdash,      XK_plusminus,   XK_onequarter,  XK_onehalf,
124         XK_threequarters,
125                         XK_agrave,      XK_aacute,      XK_acircumflex,
126         XK_atilde,      XK_adiaeresis,  XK_aring,       XK_ccedilla,
127         XK_egrave,      XK_eacute,      XK_ecircumflex, XK_ediaeresis,
128 // 224
129         XK_igrave,      XK_AE,          XK_iacute,      XK_ordfeminine,
130         XK_icircumflex, XK_idiaeresis,  XK_eth,         XK_ntilde,
131         XK_Lstroke,     XK_Ooblique,    XK_OE,          XK_masculine,
132         XK_ograve,      XK_oacute,      XK_ocircumflex, XK_otilde,
133 // 240
134         XK_odiaeresis,  XK_ae,          XK_ugrave,      XK_uacute,
135         XK_ucircumflex, XK_idotless,    XK_udiaeresis,  XK_ygrave,
136         XK_lstroke,     XK_ooblique,    XK_oe,          XK_ssharp,
137         XK_thorn,       XK_ydiaeresis,  NoSymbol,       NoSymbol,
138   };
139
140 #define MIN_SYMBOL              0xAC
141 static KeySym const symbol_to_x[] = {
142     XK_Left,        XK_Up,          XK_Right,      XK_Down
143   };
144 int const NUM_SYMBOL = sizeof(symbol_to_x) / sizeof(symbol_to_x[0]);
145
146 #define MIN_FUNCKEY             0x20
147 static KeySym const funckey_to_x[] = {
148     XK_F1,          XK_F2,          XK_F3,          XK_F4,
149     XK_F5,          XK_F6,          XK_F7,          XK_F8,
150     XK_F9,          XK_F10,         XK_F11,         XK_F12,
151     XK_Insert,      XK_Delete,      XK_Home,        XK_End,
152     XK_Page_Up,     XK_Page_Down,   XK_F13,         XK_F14,
153     XK_F15
154   };
155 int const NUM_FUNCKEY = sizeof(funckey_to_x) / sizeof(funckey_to_x[0]);
156
157 typedef struct {
158     KeySym              normalSym;
159     KeySym              keypadSym;
160 } darwinKeyPad_t;
161
162 static darwinKeyPad_t const normal_to_keypad[] = {
163     { XK_0,         XK_KP_0 },
164     { XK_1,         XK_KP_1 },
165     { XK_2,         XK_KP_2 },
166     { XK_3,         XK_KP_3 },
167     { XK_4,         XK_KP_4 },
168     { XK_5,         XK_KP_5 },
169     { XK_6,         XK_KP_6 },
170     { XK_7,         XK_KP_7 },
171     { XK_8,         XK_KP_8 },
172     { XK_9,         XK_KP_9 },
173     { XK_equal,     XK_KP_Equal },
174     { XK_asterisk,  XK_KP_Multiply },
175     { XK_plus,      XK_KP_Add },
176     { XK_comma,     XK_KP_Separator },
177     { XK_minus,     XK_KP_Subtract },
178     { XK_period,    XK_KP_Decimal },
179     { XK_slash,     XK_KP_Divide }
180 };
181 int const NUM_KEYPAD = sizeof(normal_to_keypad) / sizeof(normal_to_keypad[0]);
182
183
184 //-----------------------------------------------------------------------------
185 // Data Stream Object
186 //      Can be configured to treat embedded "numbers" as being composed of
187 //      either 1, 2, or 4 bytes, apiece.
188 //-----------------------------------------------------------------------------
189 typedef struct _DataStream
190 {
191     unsigned char const *data;
192     unsigned char const *data_end;
193     short number_size;  // Size in bytes of a "number" in the stream.
194 } DataStream;
195
196 static DataStream* new_data_stream( unsigned char const* data, int size )
197 {
198     DataStream* s = (DataStream*)xalloc( sizeof(DataStream) );
199     s->data = data;
200     s->data_end = data + size;
201     s->number_size = 1; // Default to byte-sized numbers.
202     return s;
203 }
204
205 static void destroy_data_stream( DataStream* s )
206 {
207     xfree(s);
208 }
209
210 static unsigned char get_byte( DataStream* s )
211 {
212     assert(s->data + 1 <= s->data_end);
213     return *s->data++;
214 }
215
216 static short get_word( DataStream* s )
217 {
218     short hi, lo;
219     assert(s->data + 2 <= s->data_end);
220     hi = *s->data++;
221     lo = *s->data++;
222     return ((hi << 8) | lo);
223 }
224
225 static int get_dword( DataStream* s )
226 {
227     int b1, b2, b3, b4;
228     assert(s->data + 4 <= s->data_end);
229     b4 = *s->data++;
230     b3 = *s->data++;
231     b2 = *s->data++;
232     b1 = *s->data++;
233     return ((b4 << 24) | (b3 << 16) | (b2 << 8) | b1);
234 }
235
236 static int get_number( DataStream* s )
237 {
238     switch (s->number_size) {
239         case 4:  return get_dword(s);
240         case 2:  return get_word(s);
241         default: return get_byte(s);
242     }
243 }
244
245
246 //-----------------------------------------------------------------------------
247 // Utility functions to help parse Darwin keymap
248 //-----------------------------------------------------------------------------
249
250 /*
251  * bits_set
252  *      Calculate number of bits set in the modifier mask.
253  */
254 static short bits_set( short mask )
255 {
256     short n = 0;
257
258     for ( ; mask != 0; mask >>= 1)
259         if ((mask & 0x01) != 0)
260             n++;
261     return n;
262 }
263
264 /*
265  * parse_next_char_code
266  *      Read the next character code from the Darwin keymapping
267  *      and write it to the X keymap.
268  */
269 static void parse_next_char_code(
270     DataStream  *s,
271     KeySym      *k )
272 {
273     const short charSet = get_number(s);
274     const short charCode = get_number(s);
275
276     if (charSet == 0) {                 // ascii character
277         if (charCode >= 0 && charCode < 256)
278             *k = next_to_x[charCode];
279     } else if (charSet == 0x01) {       // symbol character
280         if (charCode >= MIN_SYMBOL &&
281             charCode <= MIN_SYMBOL + NUM_SYMBOL)
282             *k = symbol_to_x[charCode - MIN_SYMBOL];
283     } else if (charSet == 0xFE) {       // function key
284         if (charCode >= MIN_FUNCKEY &&
285             charCode <= MIN_FUNCKEY + NUM_FUNCKEY)
286             *k = funckey_to_x[charCode - MIN_FUNCKEY];
287     }
288 }
289
290 /*
291  * DarwinReadKeymapFile
292  *      Read the appropriate keymapping from a keymapping file.
293  */
294 static Bool _DarwinReadKeymapFile(
295     NXKeyMapping        *keyMap)
296 {
297     struct stat         st;
298     NXEventSystemDevice info[20];
299     int                 interface = 0, handler_id = 0;
300     int                 map_interface, map_handler_id, map_size = 0;
301     unsigned int        i, size;
302     int                 *bufferEnd;
303     union km_tag {
304         int             *intP;
305         char            *charP;
306     } km;
307     char *filename;
308
309     filename = DarwinFindLibraryFile (darwinKeymapFile, "Keyboards");
310     if (filename == NULL) {
311         FatalError("Could not find keymapping file %s.\n", darwinKeymapFile);
312         return FALSE;
313     }
314
315     fref = fopen( filename, "rb" );
316     xfree (filename);
317
318     if (fref == NULL) {
319         ErrorF("Unable to open keymapping file '%s' (errno %d).\n",
320                darwinKeymapFile, errno);
321         return FALSE;
322     }
323     if (fstat(fileno(fref), &st) == -1) {
324         ErrorF("Could not stat keymapping file '%s' (errno %d).\n",
325                darwinKeymapFile, errno);
326         return FALSE;
327     }
328
329     // check to make sure we don't crash later
330     if (st.st_size <= 16*sizeof(int)) {
331         ErrorF("Keymapping file '%s' is invalid (too small).\n",
332                darwinKeymapFile);
333         return FALSE;
334     }
335
336     inBuffer = (char*) xalloc( st.st_size );
337     bufferEnd = (int *) (inBuffer + st.st_size);
338     if (fread(inBuffer, st.st_size, 1, fref) != 1) {
339         ErrorF("Could not read %qd bytes from keymapping file '%s' (errno %d).\n",
340                st.st_size, darwinKeymapFile, errno);
341         return FALSE;
342     }
343
344     if (strncmp( inBuffer, "KYM1", 4 ) == 0) {
345         // Magic number OK.
346     } else if (strncmp( inBuffer, "KYMP", 4 ) == 0) {
347         ErrorF("Keymapping file '%s' is intended for use with the original NeXT keyboards and cannot be used by XDarwin.\n", darwinKeymapFile);
348         return FALSE;
349     } else {
350         ErrorF("Keymapping file '%s' has a bad magic number and cannot be used by XDarwin.\n", darwinKeymapFile);
351         return FALSE;
352     }
353
354     // find the keyboard interface and handler id
355     {NXEventHandle hid;
356      NXEventSystemInfoType info_type;
357
358      size = sizeof( info ) / sizeof( int );
359      hid = NXOpenEventStatus ();
360      info_type = NXEventSystemInfo (hid, NX_EVS_DEVICE_INFO,
361                                     (int *) info, &size);
362      NXCloseEventStatus (hid);
363      if (!info_type) {
364          ErrorF("Error reading event status driver info.\n");
365          return FALSE;
366      }}
367
368     size = size * sizeof( int ) / sizeof( info[0] );
369     for( i = 0; i < size; i++) {
370         if (info[i].dev_type == NX_EVS_DEVICE_TYPE_KEYBOARD) {
371             Bool hasInterface = FALSE;
372             Bool hasMatch = FALSE;
373
374             interface = info[i].interface;
375             handler_id = info[i].id;
376
377             // Find an appropriate keymapping:
378             // The first time we try to match both interface and handler_id.
379             // If we can't match both, we take the first match for interface.
380
381             do {
382                 km.charP = inBuffer;
383                 km.intP++;
384                 while (km.intP+3 < bufferEnd) {
385                     map_interface = NXSwapBigIntToHost(*(km.intP++));
386                     map_handler_id = NXSwapBigIntToHost(*(km.intP++));
387                     map_size = NXSwapBigIntToHost(*(km.intP++));
388                     if (map_interface == interface) {
389                         if (map_handler_id == handler_id || hasInterface) {
390                             hasMatch = TRUE;
391                             break;
392                         } else {
393                             hasInterface = TRUE;
394                         }
395                     }
396                     km.charP += map_size;
397                 }
398             } while (hasInterface && !hasMatch);
399
400             if (hasMatch) {
401                 // fill in NXKeyMapping structure
402                 keyMap->size = map_size;
403                 keyMap->mapping = (char*) xalloc(map_size);
404                 memcpy(keyMap->mapping, km.charP, map_size);
405                 return TRUE;
406             }
407         } // if dev_id == keyboard device
408     } // foreach info struct
409
410     // The keymapping file didn't match any of the info structs
411     // returned by NXEventSystemInfo.
412     ErrorF("Keymapping file '%s' did not contain appropriate keyboard interface.\n", darwinKeymapFile);
413     return FALSE;
414 }
415
416 static Bool DarwinReadKeymapFile(NXKeyMapping *keyMap)
417 {
418     Bool ret;
419
420     ret = _DarwinReadKeymapFile (keyMap);
421
422     if (inBuffer != NULL)
423         xfree (inBuffer);
424     if (fref != NULL)
425         fclose (fref);
426
427     return ret;
428 }
429
430 int DarwinParseKeymapFile (darwin_keyboard_info *info)
431 {
432     short numMods, numKeys, numPadKeys = 0;
433     NXKeyMapping keyMap;
434     DataStream *keyMapStream;
435     unsigned char const *numPadStart = 0;
436     Bool haveKeymap;
437     int i;
438     KeySym *k;
439
440     if (darwinKeymapFile == NULL)
441         return FALSE;
442
443     haveKeymap = DarwinReadKeymapFile(&keyMap);
444     if (!haveKeymap) {
445         ErrorF("Reverting to system keymapping.\n");
446         return FALSE;
447     }
448
449     keyMapStream = new_data_stream( (unsigned char const*)keyMap.mapping,
450                                     keyMap.size );
451
452     // check the type of map
453     if (get_word(keyMapStream)) {
454         keyMapStream->number_size = 2;
455         ErrorF("Current 16-bit keymapping may not be interpreted correctly.\n");
456     }
457
458     // Compute the modifier map and
459     // insert X modifier KeySyms into keyboard map.
460     // Store modifier keycodes in modifierKeycodes.
461     numMods = get_number(keyMapStream);
462     while (numMods-- > 0) {
463         int             left = 1;               // first keycode is left
464         short const     charCode = get_number(keyMapStream);
465         short           numKeyCodes = get_number(keyMapStream);
466
467         // This is just a marker, not a real modifier.
468         // Store numeric keypad keys for later.
469         if (charCode == NX_MODIFIERKEY_NUMERICPAD) {
470             numPadStart = keyMapStream->data;
471             numPadKeys = numKeyCodes;
472         }
473
474         while (numKeyCodes-- > 0) {
475             const short keyCode = get_number(keyMapStream);
476             if (charCode != NX_MODIFIERKEY_NUMERICPAD) {
477                 switch (charCode) {
478                     case NX_MODIFIERKEY_ALPHALOCK:
479                         info->key_map[keyCode * GLYPHS_PER_KEY] = XK_Caps_Lock;
480                         break;
481                     case NX_MODIFIERKEY_SHIFT:
482                         info->key_map[keyCode * GLYPHS_PER_KEY] =
483                                 (left ? XK_Shift_L : XK_Shift_R);
484                         break;
485                     case NX_MODIFIERKEY_CONTROL:
486                         info->key_map[keyCode * GLYPHS_PER_KEY] =
487                                 (left ? XK_Control_L : XK_Control_R);
488                         break;
489                     case NX_MODIFIERKEY_ALTERNATE:
490                         info->key_map[keyCode * GLYPHS_PER_KEY] =
491                                 (left ? XK_Alt_L : XK_Alt_R);
492                         break;
493                     case NX_MODIFIERKEY_COMMAND:
494                         info->key_map[keyCode * GLYPHS_PER_KEY] =
495                                 (left ? XK_Meta_L : XK_Meta_R);
496                         break;
497                     case NX_MODIFIERKEY_SECONDARYFN:
498                         info->key_map[keyCode * GLYPHS_PER_KEY] =
499                                 (left ? XK_Control_L : XK_Control_R);
500                         break;
501                     case NX_MODIFIERKEY_HELP:
502                         info->key_map[keyCode * GLYPHS_PER_KEY] = XK_Help;
503                         break;
504                 }
505             }
506             left = 0;
507         }
508     }
509
510     // Convert the Darwin keyboard map to an X keyboard map.
511     // A key can have a different character code for each combination of
512     // modifiers. We currently ignore all modifier combinations except
513     // those with Shift, AlphaLock, and Alt.
514     numKeys = get_number(keyMapStream);
515     for (i = 0, k = info->key_map; i < numKeys; i++, k += GLYPHS_PER_KEY) {
516         short const     charGenMask = get_number(keyMapStream);
517         if (charGenMask != 0xFF) {              // is key bound?
518             short       numKeyCodes = 1 << bits_set(charGenMask);
519
520             // Record unmodified case
521             parse_next_char_code( keyMapStream, k );
522             numKeyCodes--;
523
524             // If AlphaLock and Shift modifiers produce different codes,
525             // we record the Shift case since X handles AlphaLock.
526             if (charGenMask & 0x01) {           // AlphaLock
527                 parse_next_char_code( keyMapStream, k+1 );
528                 numKeyCodes--;
529             }
530
531             if (charGenMask & 0x02) {           // Shift
532                 parse_next_char_code( keyMapStream, k+1 );
533                 numKeyCodes--;
534
535                 if (charGenMask & 0x01) {       // Shift-AlphaLock
536                     get_number(keyMapStream); get_number(keyMapStream);
537                     numKeyCodes--;
538                 }
539             }
540
541             // Skip the Control cases
542             if (charGenMask & 0x04) {           // Control
543                 get_number(keyMapStream); get_number(keyMapStream);
544                 numKeyCodes--;
545
546                 if (charGenMask & 0x01) {       // Control-AlphaLock
547                     get_number(keyMapStream); get_number(keyMapStream);
548                     numKeyCodes--;
549                 }
550
551                 if (charGenMask & 0x02) {       // Control-Shift
552                     get_number(keyMapStream); get_number(keyMapStream);
553                     numKeyCodes--;
554
555                     if (charGenMask & 0x01) {   // Shift-Control-AlphaLock
556                         get_number(keyMapStream); get_number(keyMapStream);
557                         numKeyCodes--;
558                     }
559                 }
560             }
561
562             // Process Alt cases
563             if (charGenMask & 0x08) {           // Alt
564                 parse_next_char_code( keyMapStream, k+2 );
565                 numKeyCodes--;
566
567                 if (charGenMask & 0x01) {       // Alt-AlphaLock
568                     parse_next_char_code( keyMapStream, k+3 );
569                     numKeyCodes--;
570                 }
571
572                 if (charGenMask & 0x02) {       // Alt-Shift
573                     parse_next_char_code( keyMapStream, k+3 );
574                     numKeyCodes--;
575
576                     if (charGenMask & 0x01) {   // Alt-Shift-AlphaLock
577                         get_number(keyMapStream); get_number(keyMapStream);
578                         numKeyCodes--;
579                     }
580                 }
581             }
582
583             while (numKeyCodes-- > 0) {
584                 get_number(keyMapStream); get_number(keyMapStream);
585             }
586
587             if (k[3] == k[2]) k[3] = NoSymbol;
588             if (k[2] == k[1]) k[2] = NoSymbol;
589             if (k[1] == k[0]) k[1] = NoSymbol;
590             if (k[0] == k[2] && k[1] == k[3]) k[2] = k[3] = NoSymbol;
591         }
592     }
593
594     // Now we have to go back through the list of keycodes that are on the
595     // numeric keypad and update the X keymap.
596     keyMapStream->data = numPadStart;
597     while(numPadKeys-- > 0) {
598         const short keyCode = get_number(keyMapStream);
599         k = &info->key_map[keyCode * GLYPHS_PER_KEY];
600         for (i = 0; i < NUM_KEYPAD; i++) {
601             if (*k == normal_to_keypad[i].normalSym) {
602                 k[0] = normal_to_keypad[i].keypadSym;
603                 break;
604             }
605         }
606     }
607
608     // free Darwin keyboard map
609     destroy_data_stream( keyMapStream );
610     xfree( keyMap.mapping );
611
612     return TRUE;
613 }