This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
/
SDL_macevents.c
778 lines (718 loc) · 24.5 KB
1
2
/*
SDL - Simple DirectMedia Layer
3
Copyright (C) 1997-2006 Sam Lantinga
4
5
This library is free software; you can redistribute it and/or
6
modify it under the terms of the GNU Lesser General Public
7
License as published by the Free Software Foundation; either
8
version 2.1 of the License, or (at your option) any later version.
9
10
11
12
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13
Lesser General Public License for more details.
14
15
16
17
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
19
Sam Lantinga
20
slouken@libsdl.org
21
*/
22
#include "SDL_config.h"
23
24
25
#include <stdio.h>
26
27
28
#if defined(__APPLE__) && defined(__MACH__)
#include <Carbon/Carbon.h>
#elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335)
29
30
31
32
33
34
35
36
37
38
39
40
#include <Carbon.h>
#else
#include <Script.h>
#include <LowMem.h>
#include <Devices.h>
#include <DiskInit.h>
#include <ToolUtils.h>
#endif
#include "SDL_events.h"
#include "SDL_video.h"
#include "SDL_syswm.h"
41
42
43
#include "../../events/SDL_events_c.h"
#include "../../events/SDL_sysevents.h"
#include "../SDL_cursor_c.h"
44
45
46
47
48
49
50
51
52
#include "SDL_macevents_c.h"
#include "SDL_mackeys.h"
#include "SDL_macmouse_c.h"
/* Define this to be able to collapse SDL windows.
#define USE_APPEARANCE_MANAGER
*/
/* Macintosh resource constants */
53
54
#define mApple 128 /* Apple menu resource */
#define iAbout 1 /* About menu item */
55
56
/* Functions to handle the About menu */
57
static void Mac_DoAppleMenu(_THIS, long item);
58
59
60
/* The translation table from a macintosh key scancode to a SDL keysym */
static SDLKey MAC_keymap[256];
61
62
static SDL_keysym *TranslateKey(int scancode, int modifiers,
SDL_keysym * keysym, int pressed);
63
64
/* Handle activation and deactivation -- returns whether an event was posted */
65
static int
66
Mac_HandleActivate(int activate)
67
{
68
69
if (activate) {
/* Show the current SDL application cursor */
70
SDL_SetCursor(NULL);
71
72
/* put our mask back case it changed during context switch */
73
SetEventMask(everyEvent & ~autoKeyMask);
74
} else {
75
#if TARGET_API_MAC_CARBON
76
77
{
Cursor cursor;
78
SetCursor(GetQDGlobalsArrow(&cursor));
79
}
80
#else
81
SetCursor(&theQD->arrow);
82
#endif
83
if (!Mac_cursor_showing) {
84
ShowCursor();
85
86
87
Mac_cursor_showing = 1;
}
}
88
return (SDL_PrivateAppActive(activate, SDL_APPINPUTFOCUS));
89
90
}
91
static void
92
myGlobalToLocal(_THIS, Point * pt)
93
{
94
95
if (SDL_VideoSurface && !(SDL_VideoSurface->flags & SDL_FULLSCREEN)) {
GrafPtr saveport;
96
GetPort(&saveport);
97
#if TARGET_API_MAC_CARBON
98
SetPort(GetWindowPort(SDL_Window));
99
#else
100
SetPort(SDL_Window);
101
#endif
102
103
GlobalToLocal(pt);
SetPort(saveport);
104
}
105
106
107
}
/* The main MacOS event handler */
108
static int
109
Mac_HandleEvents(_THIS, int wait4it)
110
{
111
112
113
static int mouse_button = 1;
int i;
EventRecord event;
114
115
#if TARGET_API_MAC_CARBON
116
/* There's no GetOSEvent() in the Carbon API. *sigh* */
117
118
#define cooperative_multitasking 1
#else
119
120
121
122
123
124
125
126
127
int cooperative_multitasking;
/* If we're running fullscreen, we can hog the MacOS events,
otherwise we had better play nicely with the other apps.
*/
if (this->screen && (this->screen->flags & SDL_FULLSCREEN)) {
cooperative_multitasking = 0;
} else {
cooperative_multitasking = 1;
}
128
129
#endif
130
131
132
133
134
135
136
137
138
139
140
141
/* If we call WaitNextEvent(), MacOS will check other processes
* and allow them to run, and perform other high-level processing.
*/
if (cooperative_multitasking || wait4it) {
UInt32 wait_time;
/* Are we polling or not? */
if (wait4it) {
wait_time = 2147483647;
} else {
wait_time = 0;
}
142
WaitNextEvent(everyEvent, &event, wait_time, nil);
143
} else {
144
#if ! TARGET_API_MAC_CARBON
145
GetOSEvent(everyEvent, &event);
146
#endif
147
}
148
149
#if TARGET_API_MAC_CARBON
150
/* for some reason, event.where isn't set ? */
151
GetGlobalMouse(&event.where);
152
#endif
153
154
155
156
157
/* Check for mouse motion */
if ((event.where.h != last_where.h) || (event.where.v != last_where.v)) {
Point pt;
pt = last_where = event.where;
158
159
myGlobalToLocal(this, &pt);
SDL_PrivateMouseMotion(0, 0, pt.h, pt.v);
160
161
162
}
/* Check the current state of the keyboard */
163
if (SDL_GetAppState() & SDL_APPINPUTFOCUS) {
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
KeyMap keys;
/* Check for special non-event keys */
if (event.modifiers != last_mods) {
static struct
{
EventModifiers mask;
SDLKey key;
} mods[] = {
{
alphaLock, SDLK_CAPSLOCK},
#if 0 /* These are handled below in the GetKeys() code */
{
cmdKey, SDLK_LMETA}, {
shiftKey, SDLK_LSHIFT}, {
rightShiftKey, SDLK_RSHIFT}, {
optionKey, SDLK_LALT}, {
rightOptionKey, SDLK_RALT}, {
controlKey, SDLK_LCTRL}, {
rightControlKey, SDLK_RCTRL},
184
#endif /* 0 */
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
{
0, 0}
};
SDL_keysym keysym;
Uint8 mode;
EventModifiers mod, mask;
/* Set up the keyboard event */
keysym.scancode = 0;
keysym.sym = SDLK_UNKNOWN;
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
/* See what has changed, and generate events */
mod = event.modifiers;
for (i = 0; mods[i].mask; ++i) {
mask = mods[i].mask;
if ((mod & mask) != (last_mods & mask)) {
keysym.sym = mods[i].key;
if ((mod & mask) || (mods[i].key == SDLK_CAPSLOCK)) {
mode = SDL_PRESSED;
} else {
mode = SDL_RELEASED;
}
210
SDL_PrivateKeyboard(mode, &keysym);
211
212
213
214
215
216
217
218
219
220
221
}
}
/* Save state for next time */
last_mods = mod;
}
/* Check for normal event keys, but we have to scan the
actual keyboard state because on Mac OS X a keydown event
is immediately followed by a keyup event.
*/
222
GetKeys(keys);
223
224
225
226
if ((keys[0] != last_keys[0]) || (keys[1] != last_keys[1]) ||
(keys[2] != last_keys[2]) || (keys[3] != last_keys[3])) {
SDL_keysym keysym;
int old_bit, new_bit;
227
228
#ifdef DEBUG_KEYBOARD
229
230
fprintf(sterr, "New keys: 0x%x 0x%x 0x%x 0x%x\n",
new_keys[0], new_keys[1], new_keys[2], new_keys[3]);
231
#endif
232
233
234
235
236
for (i = 0; i < 128; ++i) {
old_bit = (((Uint8 *) last_keys)[i / 8] >> (i % 8)) & 0x01;
new_bit = (((Uint8 *) keys)[i / 8] >> (i % 8)) & 0x01;
if (old_bit != new_bit) {
/* Post the keyboard event */
237
#ifdef DEBUG_KEYBOARD
238
fprintf(stderr, "Scancode: 0x%2.2X\n", i);
239
#endif
240
241
242
243
244
SDL_PrivateKeyboard(new_bit,
TranslateKey(i,
event.
modifiers,
&keysym, new_bit));
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
}
}
/* Save state for next time */
last_keys[0] = keys[0];
last_keys[1] = keys[1];
last_keys[2] = keys[2];
last_keys[3] = keys[3];
}
}
/* Handle normal events */
switch (event.what) {
case mouseDown:
{
WindowRef win;
short area;
263
area = FindWindow(event.where, &win);
264
265
266
/* Support switching between the SIOUX console
and SDL_Window by clicking in the window.
*/
267
268
if (win && (win != FrontWindow())) {
SelectWindow(win);
269
270
271
}
switch (area) {
case inMenuBar: /* Only the apple menu exists */
272
273
Mac_DoAppleMenu(this, MenuSelect(event.where));
HiliteMenu(0);
274
275
break;
case inDrag:
276
#if TARGET_API_MAC_CARBON
277
DragWindow(win, event.where, NULL);
278
#else
279
DragWindow(win, event.where, &theQD->screenBits.bounds);
280
#endif
281
282
break;
case inGoAway:
283
284
if (TrackGoAway(win, event.where)) {
SDL_PrivateQuit();
285
286
287
}
break;
case inContent:
288
myGlobalToLocal(this, &event.where);
289
290
291
292
293
294
295
296
/* Treat command-click as right mouse button */
if (event.modifiers & optionKey) {
mouse_button = 2;
} else if (event.modifiers & cmdKey) {
mouse_button = 3;
} else {
mouse_button = 1;
}
297
298
299
SDL_PrivateMouseButton(SDL_PRESSED,
mouse_button, event.where.h,
event.where.v);
300
301
302
303
304
305
306
307
308
309
break;
case inGrow:
{
int newSize;
/* Don't allow resize if video mode isn't resizable */
if (!SDL_PublicSurface ||
!(SDL_PublicSurface->flags & SDL_RESIZABLE)) {
break;
}
310
#if TARGET_API_MAC_CARBON
311
newSize = GrowWindow(win, event.where, NULL);
312
#else
313
newSize =
314
315
GrowWindow(win, event.where,
&theQD->screenBits.bounds);
316
#endif
317
if (newSize) {
318
#if !TARGET_API_MAC_CARBON
319
EraseRect(&theQD->screenBits.bounds);
320
#endif
321
322
SizeWindow(win, LoWord(newSize), HiWord(newSize), 1);
SDL_PrivateResize(LoWord(newSize), HiWord(newSize));
323
324
325
326
327
}
}
break;
case inZoomIn:
case inZoomOut:
328
if (TrackBox(win, event.where, area)) {
329
Rect rect;
330
#if !TARGET_API_MAC_CARBON
331
EraseRect(&theQD->screenBits.bounds);
332
#endif
333
ZoomWindow(win, area, 0);
334
if (area == inZoomIn) {
335
GetWindowUserState(SDL_Window, &rect);
336
} else {
337
GetWindowStandardState(SDL_Window, &rect);
338
}
339
340
SDL_PrivateResize(rect.right - rect.left,
rect.bottom - rect.top);
341
342
}
break;
343
#if TARGET_API_MAC_CARBON
344
case inCollapseBox:
345
346
347
if (TrackBox(win, event.where, area)) {
if (IsWindowCollapsable(win)) {
CollapseWindow(win, !IsWindowCollapsed(win));
348
349
350
351
/* There should be something done like in inGrow case, but... */
}
}
break;
352
#endif /* TARGET_API_MAC_CARBON */
353
case inSysWindow:
354
#if TARGET_API_MAC_CARBON
355
/* Never happens in Carbon? */
356
#else
357
SystemClick(&event, win);
358
#endif
359
360
361
362
363
364
365
366
break;
default:
break;
}
}
break;
case mouseUp:
{
367
myGlobalToLocal(this, &event.where);
368
369
370
371
372
373
/* Release the mouse button we simulated in the last press.
The drawback of this methos is we cannot press more than
one button. However, this doesn't matter, since there is
only a single logical mouse button, even if you have a
multi-button mouse, this doesn't matter at all.
*/
374
375
376
SDL_PrivateMouseButton(SDL_RELEASED,
mouse_button, event.where.h,
event.where.v);
377
378
379
380
381
382
383
}
break;
#if 0 /* Handled above the switch statement */
case keyDown:
{
SDL_keysym keysym;
384
385
386
387
SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey((event.
message & keyCodeMask) >> 8
event.modifiers, &keysym, 1));
388
389
390
391
392
393
}
break;
case keyUp:
{
SDL_keysym keysym;
394
395
396
397
SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey((event.
message & keyCodeMask) >> 8
event.modifiers, &keysym, 0));
398
399
}
break;
400
#endif
401
402
case updateEvt:
{
403
BeginUpdate(SDL_Window);
404
405
#if SDL_VIDEO_OPENGL
if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL)
406
SDL_GL_SwapBuffers();
407
408
409
else
#endif
if ((SDL_VideoSurface->flags & SDL_HWSURFACE) == SDL_SWSURFACE) {
410
SDL_UpdateRect(SDL_VideoSurface, 0, 0, 0, 0);
411
}
412
EndUpdate(SDL_Window);
413
414
415
416
417
418
419
420
421
422
}
/* If this was an update event for the SIOUX console, we return 0
in order to stop an endless series of updates being triggered.
*/
if ((WindowRef) event.message != SDL_Window) {
return 0;
}
break;
case activateEvt:
{
423
Mac_HandleActivate(!!(event.modifiers & activeFlag));
424
425
426
427
}
break;
case diskEvt:
{
428
#if TARGET_API_MAC_CARBON
429
/* What are we supposed to do? */ ;
430
#else
431
432
if (((event.message >> 16) & 0xFFFF) != noErr) {
Point spot;
433
434
SetPt(&spot, 0x0070, 0x0050);
DIBadMount(spot, event.message);
435
}
436
#endif
437
438
439
440
441
442
443
444
}
break;
case osEvt:
{
switch ((event.message >> 24) & 0xFF) {
#if 0 /* Handled above the switch statement */
case mouseMovedMessage:
{
445
446
447
myGlobalToLocal(this, &event.where);
SDL_PrivateMouseMotion(0, 0,
event.where.h, event.where.v);
448
449
}
break;
450
#endif /* 0 */
451
452
case suspendResumeMessage:
{
453
Mac_HandleActivate(!!(event.message & resumeFlag));
454
455
456
457
458
459
460
461
462
463
464
465
}
break;
}
}
break;
default:
{
;
}
break;
}
return (event.what != nullEvent);
466
467
468
}
469
void
470
Mac_PumpEvents(_THIS)
471
{
472
/* Process pending MacOS events */
473
while (Mac_HandleEvents(this, 0)) {
474
475
/* Loop and check again */ ;
}
476
477
}
478
void
479
Mac_InitOSKeymap(_THIS)
480
{
481
482
483
484
485
486
487
const void *KCHRPtr;
UInt32 state;
UInt32 value;
int i;
int world = SDLK_WORLD_0;
/* Map the MAC keysyms */
488
for (i = 0; i < SDL_arraysize(MAC_keymap); ++i)
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
MAC_keymap[i] = SDLK_UNKNOWN;
/* Defined MAC_* constants */
MAC_keymap[MK_ESCAPE] = SDLK_ESCAPE;
MAC_keymap[MK_F1] = SDLK_F1;
MAC_keymap[MK_F2] = SDLK_F2;
MAC_keymap[MK_F3] = SDLK_F3;
MAC_keymap[MK_F4] = SDLK_F4;
MAC_keymap[MK_F5] = SDLK_F5;
MAC_keymap[MK_F6] = SDLK_F6;
MAC_keymap[MK_F7] = SDLK_F7;
MAC_keymap[MK_F8] = SDLK_F8;
MAC_keymap[MK_F9] = SDLK_F9;
MAC_keymap[MK_F10] = SDLK_F10;
MAC_keymap[MK_F11] = SDLK_F11;
MAC_keymap[MK_F12] = SDLK_F12;
MAC_keymap[MK_PRINT] = SDLK_PRINT;
MAC_keymap[MK_SCROLLOCK] = SDLK_SCROLLOCK;
MAC_keymap[MK_PAUSE] = SDLK_PAUSE;
MAC_keymap[MK_POWER] = SDLK_POWER;
MAC_keymap[MK_BACKQUOTE] = SDLK_BACKQUOTE;
MAC_keymap[MK_1] = SDLK_1;
MAC_keymap[MK_2] = SDLK_2;
MAC_keymap[MK_3] = SDLK_3;
MAC_keymap[MK_4] = SDLK_4;
MAC_keymap[MK_5] = SDLK_5;
MAC_keymap[MK_6] = SDLK_6;
MAC_keymap[MK_7] = SDLK_7;
MAC_keymap[MK_8] = SDLK_8;
MAC_keymap[MK_9] = SDLK_9;
MAC_keymap[MK_0] = SDLK_0;
MAC_keymap[MK_MINUS] = SDLK_MINUS;
MAC_keymap[MK_EQUALS] = SDLK_EQUALS;
MAC_keymap[MK_BACKSPACE] = SDLK_BACKSPACE;
MAC_keymap[MK_INSERT] = SDLK_INSERT;
MAC_keymap[MK_HOME] = SDLK_HOME;
MAC_keymap[MK_PAGEUP] = SDLK_PAGEUP;
MAC_keymap[MK_NUMLOCK] = SDLK_NUMLOCK;
MAC_keymap[MK_KP_EQUALS] = SDLK_KP_EQUALS;
MAC_keymap[MK_KP_DIVIDE] = SDLK_KP_DIVIDE;
MAC_keymap[MK_KP_MULTIPLY] = SDLK_KP_MULTIPLY;
MAC_keymap[MK_TAB] = SDLK_TAB;
MAC_keymap[MK_q] = SDLK_q;
MAC_keymap[MK_w] = SDLK_w;
MAC_keymap[MK_e] = SDLK_e;
MAC_keymap[MK_r] = SDLK_r;
MAC_keymap[MK_t] = SDLK_t;
MAC_keymap[MK_y] = SDLK_y;
MAC_keymap[MK_u] = SDLK_u;
MAC_keymap[MK_i] = SDLK_i;
MAC_keymap[MK_o] = SDLK_o;
MAC_keymap[MK_p] = SDLK_p;
MAC_keymap[MK_LEFTBRACKET] = SDLK_LEFTBRACKET;
MAC_keymap[MK_RIGHTBRACKET] = SDLK_RIGHTBRACKET;
MAC_keymap[MK_BACKSLASH] = SDLK_BACKSLASH;
MAC_keymap[MK_DELETE] = SDLK_DELETE;
MAC_keymap[MK_END] = SDLK_END;
MAC_keymap[MK_PAGEDOWN] = SDLK_PAGEDOWN;
MAC_keymap[MK_KP7] = SDLK_KP7;
MAC_keymap[MK_KP8] = SDLK_KP8;
MAC_keymap[MK_KP9] = SDLK_KP9;
MAC_keymap[MK_KP_MINUS] = SDLK_KP_MINUS;
MAC_keymap[MK_CAPSLOCK] = SDLK_CAPSLOCK;
MAC_keymap[MK_a] = SDLK_a;
MAC_keymap[MK_s] = SDLK_s;
MAC_keymap[MK_d] = SDLK_d;
MAC_keymap[MK_f] = SDLK_f;
MAC_keymap[MK_g] = SDLK_g;
MAC_keymap[MK_h] = SDLK_h;
MAC_keymap[MK_j] = SDLK_j;
MAC_keymap[MK_k] = SDLK_k;
MAC_keymap[MK_l] = SDLK_l;
MAC_keymap[MK_SEMICOLON] = SDLK_SEMICOLON;
MAC_keymap[MK_QUOTE] = SDLK_QUOTE;
MAC_keymap[MK_RETURN] = SDLK_RETURN;
MAC_keymap[MK_KP4] = SDLK_KP4;
MAC_keymap[MK_KP5] = SDLK_KP5;
MAC_keymap[MK_KP6] = SDLK_KP6;
MAC_keymap[MK_KP_PLUS] = SDLK_KP_PLUS;
MAC_keymap[MK_LSHIFT] = SDLK_LSHIFT;
MAC_keymap[MK_z] = SDLK_z;
MAC_keymap[MK_x] = SDLK_x;
MAC_keymap[MK_c] = SDLK_c;
MAC_keymap[MK_v] = SDLK_v;
MAC_keymap[MK_b] = SDLK_b;
MAC_keymap[MK_n] = SDLK_n;
MAC_keymap[MK_m] = SDLK_m;
MAC_keymap[MK_COMMA] = SDLK_COMMA;
MAC_keymap[MK_PERIOD] = SDLK_PERIOD;
MAC_keymap[MK_SLASH] = SDLK_SLASH;
#if 0 /* These are the same as the left versions - use left by default */
MAC_keymap[MK_RSHIFT] = SDLK_RSHIFT;
581
#endif
582
583
584
585
586
587
588
589
590
591
592
593
594
MAC_keymap[MK_UP] = SDLK_UP;
MAC_keymap[MK_KP1] = SDLK_KP1;
MAC_keymap[MK_KP2] = SDLK_KP2;
MAC_keymap[MK_KP3] = SDLK_KP3;
MAC_keymap[MK_KP_ENTER] = SDLK_KP_ENTER;
MAC_keymap[MK_LCTRL] = SDLK_LCTRL;
MAC_keymap[MK_LALT] = SDLK_LALT;
MAC_keymap[MK_LMETA] = SDLK_LMETA;
MAC_keymap[MK_SPACE] = SDLK_SPACE;
#if 0 /* These are the same as the left versions - use left by default */
MAC_keymap[MK_RMETA] = SDLK_RMETA;
MAC_keymap[MK_RALT] = SDLK_RALT;
MAC_keymap[MK_RCTRL] = SDLK_RCTRL;
595
#endif
596
597
598
599
600
MAC_keymap[MK_LEFT] = SDLK_LEFT;
MAC_keymap[MK_DOWN] = SDLK_DOWN;
MAC_keymap[MK_RIGHT] = SDLK_RIGHT;
MAC_keymap[MK_KP0] = SDLK_KP0;
MAC_keymap[MK_KP_PERIOD] = SDLK_KP_PERIOD;
601
602
#if defined(__APPLE__) && defined(__MACH__)
603
604
605
606
607
608
609
610
/* Wierd, these keys are on my iBook under Mac OS X
Note that the left arrow keysym is the same as left ctrl!?
*/
MAC_keymap[MK_IBOOK_ENTER] = SDLK_KP_ENTER;
MAC_keymap[MK_IBOOK_RIGHT] = SDLK_RIGHT;
MAC_keymap[MK_IBOOK_DOWN] = SDLK_DOWN;
MAC_keymap[MK_IBOOK_UP] = SDLK_UP;
MAC_keymap[MK_IBOOK_LEFT] = SDLK_LEFT;
611
#endif /* Mac OS X */
612
613
614
615
616
617
618
619
620
/* Up there we setup a static scancode->keysym map. However, it will not
* work very well on international keyboard. Hence we now query MacOS
* for its own keymap to adjust our own mapping table. However, this is
* bascially only useful for ascii char keys. This is also the reason
* why we keep the static table, too.
*/
/* Get a pointer to the systems cached KCHR */
621
KCHRPtr = (void *) GetScriptManagerVariable(smKCHRCache);
622
623
624
625
626
627
628
if (KCHRPtr) {
/* Loop over all 127 possible scan codes */
for (i = 0; i < 0x7F; i++) {
/* We pretend a clean start to begin with (i.e. no dead keys active */
state = 0;
/* Now translate the key code to a key value */
629
value = KeyTranslate(KCHRPtr, i, &state) & 0xff;
630
631
632
633
/* If the state become 0, it was a dead key. We need to translate again,
passing in the new state, to get the actual key value */
if (state != 0)
634
value = KeyTranslate(KCHRPtr, i, &state) & 0xff;
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
/* Now we should have an ascii value, or 0. Try to figure out to which SDL symbol it maps */
if (value >= 128) /* Some non-ASCII char, map it to SDLK_WORLD_* */
MAC_keymap[i] = world++;
else if (value >= 32) /* non-control ASCII char */
MAC_keymap[i] = value;
}
}
/* The keypad codes are re-setup here, because the loop above cannot
* distinguish between a key on the keypad and a regular key. We maybe
* could get around this problem in another fashion: NSEvent's flags
* include a "NSNumericPadKeyMask" bit; we could check that and modify
* the symbol we return on the fly. However, this flag seems to exhibit
* some weird behaviour related to the num lock key
*/
MAC_keymap[MK_KP0] = SDLK_KP0;
MAC_keymap[MK_KP1] = SDLK_KP1;
MAC_keymap[MK_KP2] = SDLK_KP2;
MAC_keymap[MK_KP3] = SDLK_KP3;
MAC_keymap[MK_KP4] = SDLK_KP4;
MAC_keymap[MK_KP5] = SDLK_KP5;
MAC_keymap[MK_KP6] = SDLK_KP6;
MAC_keymap[MK_KP7] = SDLK_KP7;
MAC_keymap[MK_KP8] = SDLK_KP8;
MAC_keymap[MK_KP9] = SDLK_KP9;
MAC_keymap[MK_KP_MINUS] = SDLK_KP_MINUS;
MAC_keymap[MK_KP_PLUS] = SDLK_KP_PLUS;
MAC_keymap[MK_KP_PERIOD] = SDLK_KP_PERIOD;
MAC_keymap[MK_KP_EQUALS] = SDLK_KP_EQUALS;
MAC_keymap[MK_KP_DIVIDE] = SDLK_KP_DIVIDE;
MAC_keymap[MK_KP_MULTIPLY] = SDLK_KP_MULTIPLY;
MAC_keymap[MK_KP_ENTER] = SDLK_KP_ENTER;
668
669
}
670
static SDL_keysym *
671
TranslateKey(int scancode, int modifiers, SDL_keysym * keysym, int pressed)
672
{
673
674
675
676
677
678
679
680
681
682
683
/* Set the keysym information */
keysym->scancode = scancode;
keysym->sym = MAC_keymap[keysym->scancode];
keysym->mod = KMOD_NONE;
keysym->unicode = 0;
if (pressed && SDL_TranslateUNICODE) {
static unsigned long state = 0;
static Ptr keymap = nil;
Ptr new_keymap;
/* Get the current keyboard map resource */
684
new_keymap = (Ptr) GetScriptManagerVariable(smKCHRCache);
685
686
687
688
if (new_keymap != keymap) {
keymap = new_keymap;
state = 0;
}
689
690
691
keysym->unicode = KeyTranslate(keymap,
keysym->scancode | modifiers,
&state) & 0xFFFF;
692
693
}
return (keysym);
694
695
}
696
void
697
Mac_InitEvents(_THIS)
698
{
699
/* Create apple menu bar */
700
apple_menu = GetMenu(mApple);
701
if (apple_menu != nil) {
702
703
AppendResMenu(apple_menu, 'DRVR');
InsertMenu(apple_menu, 0);
704
}
705
DrawMenuBar();
706
707
/* Get rid of spurious events at startup */
708
FlushEvents(everyEvent, 0);
709
710
/* Allow every event but keyrepeat */
711
SetEventMask(everyEvent & ~autoKeyMask);
712
713
}
714
void
715
Mac_QuitEvents(_THIS)
716
{
717
ClearMenuBar();
718
if (apple_menu != nil) {
719
ReleaseResource((char **) apple_menu);
720
}
721
722
/* Clean up pending events */
723
FlushEvents(everyEvent, 0);
724
725
}
726
static void
727
Mac_DoAppleMenu(_THIS, long choice)
728
{
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
#if !TARGET_API_MAC_CARBON /* No Apple menu in OS X */
short menu, item;
item = (choice & 0xFFFF);
choice >>= 16;
menu = (choice & 0xFFFF);
switch (menu) {
case mApple:
{
switch (item) {
case iAbout:
{
/* Run the about box */ ;
}
break;
default:
{
Str255 name;
749
750
GetMenuItemText(apple_menu, item, name);
OpenDeskAcc(name);
751
752
753
754
755
756
757
758
759
760
}
break;
}
}
break;
default:
{
/* Ignore other menus */ ;
}
}
761
762
763
764
765
766
#endif /* !TARGET_API_MAC_CARBON */
}
#if !TARGET_API_MAC_CARBON
/* Since we don't initialize QuickDraw, we need to get a pointer to qd */
QDGlobals *theQD = NULL;
767
#endif
768
769
/* Exported to the macmain code */
770
void
771
SDL_InitQuickDraw(struct QDGlobals *the_qd)
772
{
773
#if !TARGET_API_MAC_CARBON
774
theQD = the_qd;
775
#endif
776
}
777
778
/* vi: set ts=4 sw=4 expandtab: */