Split tangents are now red and merged tangents are yellow.
[synfig.git] / synfig-osx / launcher / darwin-keyboard.c
1 /* darwin-keyboard.c -- Keyboard support for the Darwin X Server
2
3    Copyright (c) 2001-2002 Torrey T. Lyons. All Rights Reserved.
4    Copyright (c) 2003 Apple Computer, Inc. All Rights Reserved.
5
6    Redistribution and use in source and binary forms, with or without
7    modification, are permitted provided that the following conditions are met:
8
9      1. Redistributions of source code must retain the above copyright
10         notice, this list of conditions and the following disclaimer.
11      2. Redistributions in binary form must reproduce the above copyright
12         notice, this list of conditions and the following disclaimer in the
13         documentation and/or other materials provided with the distribution.
14      3. The name of the author may not be used to endorse or promote products
15         derived from this software without specific prior written permission.
16
17    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
20    NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
22    TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
24    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
25    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
26    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
27
28 /* $XFree86: xc/programs/Xserver/hw/darwin/darwinKeyboard.c,v 1.16 2002/03/28 02:21:08 torrey Exp $ */
29
30
31 /* An X keyCode must be in the range XkbMinLegalKeyCode (8) to
32    XkbMaxLegalKeyCode(255).
33
34    The keyCodes we get from the kernel range from 0 to 127, so we need to
35    offset the range before passing the keyCode to X.
36
37    An X KeySym is an extended ascii code that is device independent.
38
39    The modifier map is accessed by the keyCode, but the normal map is
40    accessed by keyCode - MIN_KEYCODE.  Sigh. */
41
42
43 /* Define this to get a diagnostic output to stderr which is helpful
44    in determining how the X server is interpreting the Darwin keymap. */
45 #undef DUMP_DARWIN_KEYMAP
46
47 /* Define this to use Alt for Mode_switch. */
48 #define ALT_IS_MODE_SWITCH 1
49
50 #include "darwin.h"
51 #include "darwin-keyboard.h"
52
53 #include <stdio.h>
54 #include <stdlib.h>
55 #include "darwin.h"
56 #include "quartz-audio.h"
57
58 /* For NX_ constants */
59 #include <IOKit/hidsystem/IOLLEvent.h>
60 #include <IOKit/hidsystem/ev_keymap.h>
61
62 #include "keysym.h"
63
64 static darwin_keyboard_info info;
65
66 static void
67 DarwinChangeKeyboardControl (DeviceIntPtr device, KeybdCtrl *ctrl)
68 {
69     /* keyclick, bell volume / pitch, autorepeat, LED's */
70 }
71
72 /* Use the key_map field of INFO to populate the mod_map and
73    modifier_keycodes fields */
74 static void
75 build_modifier_maps (darwin_keyboard_info *info)
76 {
77     int i;
78     KeySym *k;
79
80     memset (info->mod_map, NoSymbol, sizeof (info->mod_map));
81     memset (info->modifier_keycodes, 0, sizeof (info->modifier_keycodes));
82
83     for (i = 0; i < NUM_KEYCODES; i++)
84     {
85         k = info->key_map + i * GLYPHS_PER_KEY;
86
87         switch (k[0])
88         {
89         case XK_Shift_L:
90             info->modifier_keycodes[NX_MODIFIERKEY_SHIFT][0] = i;
91             info->mod_map[MIN_KEYCODE + i] = ShiftMask;
92             break;
93
94         case XK_Shift_R:
95             info->modifier_keycodes[NX_MODIFIERKEY_SHIFT][1] = i;
96             info->mod_map[MIN_KEYCODE + i] = ShiftMask;
97             break;
98
99         case XK_Control_L:
100             info->modifier_keycodes[NX_MODIFIERKEY_CONTROL][0] = i;
101             info->mod_map[MIN_KEYCODE + i] = ControlMask;
102             break;
103
104         case XK_Control_R:
105             info->modifier_keycodes[NX_MODIFIERKEY_CONTROL][1] = i;
106             info->mod_map[MIN_KEYCODE + i] = ControlMask;
107             break;
108
109         case XK_Caps_Lock:
110             info->modifier_keycodes[NX_MODIFIERKEY_ALPHALOCK][0] = i;
111             info->mod_map[MIN_KEYCODE + i] = LockMask;
112             break;
113
114         case XK_Alt_L:
115             info->modifier_keycodes[NX_MODIFIERKEY_ALTERNATE][0] = i;
116             info->mod_map[MIN_KEYCODE + i] = Mod1Mask;
117             break;
118
119         case XK_Alt_R:
120             info->modifier_keycodes[NX_MODIFIERKEY_ALTERNATE][1] = i;
121             info->mod_map[MIN_KEYCODE + i] = Mod1Mask;
122             break;
123
124         case XK_Mode_switch:
125             info->mod_map[MIN_KEYCODE + i] = Mod1Mask;
126             break;
127
128         case XK_Meta_L:
129             info->modifier_keycodes[NX_MODIFIERKEY_COMMAND][0] = i;
130             info->mod_map[MIN_KEYCODE + i] = Mod2Mask;
131             break;
132
133         case XK_Meta_R:
134             info->modifier_keycodes[NX_MODIFIERKEY_COMMAND][1] = i;
135             info->mod_map[MIN_KEYCODE + i] = Mod2Mask;
136             break;
137
138         case XK_Num_Lock:
139             info->mod_map[MIN_KEYCODE + i] = Mod3Mask;
140             break;    
141         }
142
143         if (darwinSwapAltMeta)
144         {
145             switch (k[0])
146             {
147             case XK_Alt_L:
148                 k[0] = XK_Meta_L; break;
149             case XK_Alt_R:
150                 k[0] = XK_Meta_R; break;
151             case XK_Meta_L:
152                 k[0] = XK_Alt_L; break;
153             case XK_Meta_R:
154                 k[0] = XK_Alt_R; break;
155             }
156         }
157
158 #if ALT_IS_MODE_SWITCH
159         if (k[0] == XK_Alt_L || k[0] == XK_Alt_R)
160             k[0] = XK_Mode_switch;
161 #endif
162     }
163 }
164
165 static void
166 load_keyboard_mapping (KeySymsRec *keysyms)
167 {
168     memset (info.key_map, 0, sizeof (info.key_map));
169
170     if (darwinKeymapFile == NULL
171         || !DarwinParseKeymapFile (&info))
172     {
173         /* Load the system keymapping. */
174
175         DarwinReadSystemKeymap (&info);
176     }
177
178     build_modifier_maps (&info);
179
180 #ifdef DUMP_DARWIN_KEYMAP
181     ErrorF("Darwin -> X converted keyboard map\n");
182     for (i = 0, k = map; i < NX_NUMKEYCODES; i++, k += GLYPHS_PER_KEY) {
183         int j;
184         ErrorF("0x%02x:", i);
185         for (j = 0; j < GLYPHS_PER_KEY; j++) {
186             if (k[j] == NoSymbol) {
187                 ErrorF("\tNoSym");
188             } else {
189                 ErrorF("\t0x%x", k[j]);
190             }
191         }
192         ErrorF("\n");
193     }
194 #endif
195
196     keysyms->map = info.key_map;
197     keysyms->mapWidth = GLYPHS_PER_KEY;
198     keysyms->minKeyCode = MIN_KEYCODE;
199     keysyms->maxKeyCode = MAX_KEYCODE;
200 }
201
202 /* Get the Darwin keyboard map and compute an equivalent X keyboard map
203    and modifier map. Set the new keyboard device structure. */
204 void
205 DarwinKeyboardInit (DeviceIntPtr pDev)
206 {
207     KeySymsRec keysyms;
208     BellProcPtr bellProc;
209
210     load_keyboard_mapping (&keysyms);
211
212     /* Initialize the seed, so we don't reload the keymap unnecessarily
213        (and possibly overwrite xinitrc changes) */
214     DarwinSystemKeymapSeed ();
215
216     bellProc = QuartzBell;
217
218     InitKeyboardDeviceStruct ((DevicePtr) pDev, &keysyms, info.mod_map,
219                               bellProc, DarwinChangeKeyboardControl);
220 }
221
222 /* Borrowed from dix/devices.c */
223 static Bool
224 InitModMap(register KeyClassPtr keyc)
225 {
226     int i, j;
227     CARD8 keysPerModifier[8];
228     CARD8 mask;
229
230     if (keyc->modifierKeyMap != NULL)
231         xfree (keyc->modifierKeyMap);
232
233     keyc->maxKeysPerModifier = 0;
234     for (i = 0; i < 8; i++)
235         keysPerModifier[i] = 0;
236     for (i = 8; i < MAP_LENGTH; i++)
237     {
238         for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
239         {
240             if (mask & keyc->modifierMap[i])
241             {
242                 if (++keysPerModifier[j] > keyc->maxKeysPerModifier)
243                     keyc->maxKeysPerModifier = keysPerModifier[j];
244             }
245         }
246     }
247     keyc->modifierKeyMap = (KeyCode *)xalloc(8*keyc->maxKeysPerModifier);
248     if (!keyc->modifierKeyMap && keyc->maxKeysPerModifier)
249         return (FALSE);
250     bzero((char *)keyc->modifierKeyMap, 8*(int)keyc->maxKeysPerModifier);
251     for (i = 0; i < 8; i++)
252         keysPerModifier[i] = 0;
253     for (i = 8; i < MAP_LENGTH; i++)
254     {
255         for (j = 0, mask = 1; j < 8; j++, mask <<= 1)
256         {
257             if (mask & keyc->modifierMap[i])
258             {
259                 keyc->modifierKeyMap[(j*keyc->maxKeysPerModifier) +
260                                      keysPerModifier[j]] = i;
261                 keysPerModifier[j]++;
262             }
263         }
264     }
265     return TRUE;
266 }
267
268 void
269 DarwinKeyboardReload (DeviceIntPtr pDev)
270 {
271     KeySymsRec keysyms;
272
273     load_keyboard_mapping (&keysyms);
274
275     if (SetKeySymsMap (&pDev->key->curKeySyms, &keysyms))
276     {
277         /* now try to update modifiers. */
278
279         memmove (pDev->key->modifierMap, info.mod_map, MAP_LENGTH);
280         InitModMap (pDev->key);
281     }
282
283     SendMappingNotify (MappingKeyboard, MIN_KEYCODE, NUM_KEYCODES, 0);
284     SendMappingNotify (MappingModifier, 0, 0, 0);
285 }
286
287 /* Return the keycode for an NX_MODIFIERKEY_* modifier. side = 0 for left
288    or 1 for right. Returns 0 if key+side is not a known modifier. */
289 int
290 DarwinModifierNXKeyToNXKeycode (int key, int side)
291 {
292     return info.modifier_keycodes[key][side];
293 }
294
295 /* This allows the ddx layer to prevent some keys from being remapped
296    as modifier keys. */
297 Bool
298 LegalModifier (unsigned int key, DevicePtr pDev)
299 {
300     return 1;
301 }