Mercurial > sdl-ios-xcode

comparison src/video/maccommon/SDL_macevents.c @ 0:74212992fb08

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial revision
author Sam Lantinga <slouken@lokigames.com>
date Thu, 26 Apr 2001 16:45:43 +0000
parents
children ee3bb7cd06b5
comparison
equal deleted inserted replaced
-1:000000000000 0:74212992fb08
1 /*
2 SDL - Simple DirectMedia Layer
3 Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Library General Public
7 License as published by the Free Software Foundation; either
8 version 2 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this library; if not, write to the Free
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18
19 Sam Lantinga
20 slouken@devolution.com
21 */
22
23 #ifdef SAVE_RCSID
24 static char rcsid =
25 "@(#) $Id$";
26 #endif
27
28 #include <stdio.h>
29
30 #if TARGET_API_MAC_CARBON
31 #include <Carbon.h>
32 #else
33 #include <Script.h>
34 #include <LowMem.h>
35 #include <Devices.h>
36 #include <DiskInit.h>
37 #include <ToolUtils.h>
38 #endif
39
40 #include "SDL_events.h"
41 #include "SDL_video.h"
42 #include "SDL_error.h"
43 #include "SDL_syswm.h"
44 #include "SDL_events_c.h"
45 #include "SDL_cursor_c.h"
46 #include "SDL_sysevents.h"
47 #include "SDL_macevents_c.h"
48 #include "SDL_mackeys.h"
49 #include "SDL_macmouse_c.h"
50
51 /* Define this to be able to collapse SDL windows.
52 #define USE_APPEARANCE_MANAGER
53 */
54
55 /* Macintosh resource constants */
56 #define mApple 128 /* Apple menu resource */
57 #define iAbout 1 /* About menu item */
58
59 /* Functions to handle the About menu */
60 static void Mac_DoAppleMenu(_THIS, long item);
61
62 /* The translation table from a macintosh key scancode to a SDL keysym */
63 static SDLKey MAC_keymap[256];
64 static SDL_keysym *TranslateKey(int scancode, int modifiers,
65 SDL_keysym *keysym, int pressed);
66
67 /* Handle activation and deactivation -- returns whether an event was posted */
68 static int Mac_HandleActivate(int activate)
69 {
70 if ( activate ) {
71 /* Show the current SDL application cursor */
72 SDL_SetCursor(NULL);
73
74 /* put our mask back case it changed during context switch */
75 SetEventMask(everyEvent - autoKeyMask);
76 } else {
77 #if TARGET_API_MAC_CARBON
78 { Cursor cursor;
79 SetCursor(GetQDGlobalsArrow(&cursor));
80 }
81 #else
82 SetCursor(&theQD->arrow);
83 #endif
84 if ( ! Mac_cursor_showing ) {
85 ShowCursor();
86 Mac_cursor_showing = 1;
87 }
88 }
89 return(SDL_PrivateAppActive(activate, SDL_APPINPUTFOCUS));
90 }
91
92 static void myGlobalToLocal(_THIS, Point *pt)
93 {
94 if ( SDL_VideoSurface && !(SDL_VideoSurface->flags&SDL_FULLSCREEN) ) {
95 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 GlobalToLocal(pt);
103 SetPort(saveport);
104 }
105 }
106
107 /* The main MacOS event handler */
108 static int Mac_HandleEvents(_THIS, int wait4it)
109 {
110 int i;
111 EventRecord event;
112
113 #if TARGET_API_MAC_CARBON
114 /* There's no GetOSEvent() in the Carbon API. *sigh* */
115 #define cooperative_multitasking 1
116 #else
117 int cooperative_multitasking;
118 /* If we're running fullscreen, we can hog the MacOS events,
119 otherwise we had better play nicely with the other apps.
120 */
121 if ( this->screen && (this->screen->flags & SDL_FULLSCREEN) ) {
122 cooperative_multitasking = 0;
123 } else {
124 cooperative_multitasking = 1;
125 }
126 #endif
127
128 /* If we call WaitNextEvent(), MacOS will check other processes
129 * and allow them to run, and perform other high-level processing.
130 */
131 if ( cooperative_multitasking || wait4it ) {
132 UInt32 wait_time;
133
134 /* Are we polling or not? */
135 if ( wait4it ) {
136 wait_time = 2147483647;
137 } else {
138 wait_time = 0;
139 }
140 WaitNextEvent(everyEvent, &event, wait_time, nil);
141 } else {
142 #if ! TARGET_API_MAC_CARBON
143 GetOSEvent(everyEvent, &event);
144 #endif
145 }
146
147 #if TARGET_API_MAC_CARBON
148 /* for some reason, event.where isn't set ? */
149 GetGlobalMouse ( &event.where );
150 #endif
151
152 /* Check for mouse motion */
153 if ( (event.where.h != last_where.h) ||
154 (event.where.v != last_where.v) ) {
155 Point pt;
156 pt = last_where = event.where;
157 myGlobalToLocal(this, &pt);
158 SDL_PrivateMouseMotion(0, 0, pt.h, pt.v);
159 }
160
161 /* Check the current state of the keyboard */
162 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
163 KeyMap keys;
164
165 /* Check for special non-event keys */
166 if ( event.modifiers != last_mods ) {
167 static struct {
168 EventModifiers mask;
169 SDLKey key;
170 } mods[] = {
171 { alphaLock, SDLK_CAPSLOCK },
172 #if 0 /* These are handled below in the GetKeys() code */
173 { cmdKey, SDLK_LMETA },
174 { shiftKey, SDLK_LSHIFT },
175 { rightShiftKey, SDLK_RSHIFT },
176 { optionKey, SDLK_LALT },
177 { rightOptionKey, SDLK_RALT },
178 { controlKey, SDLK_LCTRL },
179 { rightControlKey, SDLK_RCTRL },
180 #endif /* 0 */
181 { 0, 0 }
182 };
183 SDL_keysym keysym;
184 Uint8 mode;
185 EventModifiers mod, mask;
186
187
188 /* Set up the keyboard event */
189 keysym.scancode = 0;
190 keysym.sym = SDLK_UNKNOWN;
191 keysym.mod = KMOD_NONE;
192 keysym.unicode = 0;
193
194 /* See what has changed, and generate events */
195 mod = event.modifiers;
196 for ( i=0; mods[i].mask; ++i ) {
197 mask = mods[i].mask;
198 if ( (mod&mask) != (last_mods&mask) ) {
199 keysym.sym = mods[i].key;
200 if ( (mod&mask) ||
201 (mods[i].key == SDLK_CAPSLOCK) ) {
202 mode = SDL_PRESSED;
203 } else {
204 mode = SDL_RELEASED;
205 }
206 SDL_PrivateKeyboard(mode, &keysym);
207 }
208 }
209
210 /* Save state for next time */
211 last_mods = mod;
212 }
213
214 /* Check for normal event keys, but we have to scan the
215 actual keyboard state because on MacOS X a keydown event
216 is immediately followed by a keyup event.
217 */
218 GetKeys(keys);
219 if ( (keys[0] != last_keys[0]) || (keys[1] != last_keys[1]) ||
220 (keys[2] != last_keys[2]) || (keys[3] != last_keys[3]) ) {
221 SDL_keysym keysym;
222 int old_bit, new_bit;
223
224 #ifdef DEBUG_KEYBOARD
225 fprintf(sterr, "New keys: 0x%x 0x%x 0x%x 0x%x\n",
226 new_keys[0], new_keys[1],
227 new_keys[2], new_keys[3]);
228 #endif
229 for ( i=0; i<128; ++i ) {
230 old_bit = (((Uint8 *)last_keys)[i/8]>>(i%8)) & 0x01;
231 new_bit = (((Uint8 *)keys)[i/8]>>(i%8)) & 0x01;
232 if ( old_bit != new_bit ) {
233 /* Post the keyboard event */
234 #ifdef DEBUG_KEYBOARD
235 fprintf(stderr,"Scancode: 0x%2.2X\n",i);
236 #endif
237 SDL_PrivateKeyboard(new_bit,
238 TranslateKey(i, event.modifiers,
239 &keysym, new_bit));
240 }
241 }
242
243 /* Save state for next time */
244 last_keys[0] = keys[0];
245 last_keys[1] = keys[1];
246 last_keys[2] = keys[2];
247 last_keys[3] = keys[3];
248 }
249 }
250
251 /* Handle normal events */
252 switch (event.what) {
253 case mouseDown: {
254 WindowRef win;
255 short area;
256
257 area = FindWindow(event.where, &win);
258 /* Support switching between the SIOUX console
259 and SDL_Window by clicking in the window.
260 */
261 if ( win && (win != FrontWindow()) ) {
262 SelectWindow(win);
263 }
264 switch (area) {
265 case inMenuBar: /* Only the apple menu exists */
266 Mac_DoAppleMenu(this, MenuSelect(event.where));
267 HiliteMenu(0);
268 break;
269 case inDrag:
270 #if TARGET_API_MAC_CARBON
271 DragWindow(win, event.where, NULL);
272 #else
273 DragWindow(win, event.where, &theQD->screenBits.bounds);
274 #endif
275 break;
276 case inGoAway:
277 if ( TrackGoAway(win, event.where) ) {
278 SDL_PrivateQuit();
279 }
280 break;
281 case inContent:
282 myGlobalToLocal(this, &event.where);
283 /* Treat command-click as right mouse button */
284 if ( event.modifiers & optionKey ) {
285 SDL_PrivateMouseButton(SDL_PRESSED,
286 2,event.where.h,event.where.v);
287 }
288 else if ( event.modifiers & cmdKey ) {
289 SDL_PrivateMouseButton(SDL_PRESSED,
290 3,event.where.h,event.where.v);
291 } else {
292 SDL_PrivateMouseButton(SDL_PRESSED,
293 1,event.where.h,event.where.v);
294 }
295 break;
296 case inGrow: {
297 int newSize;
298
299 /* Don't allow resize if video mode isn't resizable */
300 if ( ! SDL_PublicSurface ||
301 ! (SDL_PublicSurface->flags & SDL_RESIZABLE) ) {
302 break;
303 }
304 #if TARGET_API_MAC_CARBON
305 newSize = GrowWindow(win, event.where, NULL);
306 #else
307 newSize = GrowWindow(win, event.where, &theQD->screenBits.bounds);
308 #endif
309 if ( newSize ) {
310 #if !TARGET_API_MAC_CARBON
311 EraseRect ( &theQD->screenBits.bounds );
312 #endif
313 SizeWindow ( win, LoWord (newSize), HiWord (newSize), 1 );
314 SDL_PrivateResize ( LoWord (newSize), HiWord (newSize) );
315 }
316 } break;
317 case inZoomIn:
318 case inZoomOut:
319 if ( TrackBox (win, event.where, area )) {
320 Rect rect;
321 #if !TARGET_API_MAC_CARBON
322 EraseRect ( &theQD->screenBits.bounds );
323 #endif
324 ZoomWindow ( win, area, 0);
325 if ( area == inZoomIn ) {
326 GetWindowUserState(SDL_Window, &rect);
327 } else {
328 GetWindowStandardState(SDL_Window, &rect);
329 }
330 SDL_PrivateResize (rect.right-rect.left,
331 rect.bottom-rect.top);
332 }
333 break;
334 #if TARGET_API_MAC_CARBON
335 case inCollapseBox:
336 if ( TrackBox (win, event.where, area )) {
337 if ( IsWindowCollapsable(win) ) {
338 CollapseWindow (win, !IsWindowCollapsed(win));
339 // There should be something done like in inGrow case, but...
340 }
341 }
342 break;
343 #endif /* TARGET_API_MAC_CARBON */
344 case inSysWindow:
345 #if TARGET_API_MAC_CARBON
346 /* Never happens in Carbon? */
347 #else
348 SystemClick(&event, win);
349 #endif
350 break;
351 default:
352 break;
353 }
354 }
355 break;
356 case mouseUp: {
357 myGlobalToLocal(this, &event.where);
358 /* Treat command-click as right mouse button */
359 if ( event.modifiers & cmdKey ) {
360 SDL_PrivateMouseButton(SDL_RELEASED,
361 3, event.where.h, event.where.v);
362 }
363 else if ( event.modifiers & optionKey ) {
364 SDL_PrivateMouseButton(SDL_RELEASED,
365 2,event.where.h,event.where.v);
366 } else {
367 SDL_PrivateMouseButton(SDL_RELEASED,
368 1, event.where.h, event.where.v);
369 }
370 }
371 break;
372 #if 0 /* Handled above the switch statement */
373 case keyDown: {
374 SDL_keysym keysym;
375
376 SDL_PrivateKeyboard(SDL_PRESSED,
377 TranslateKey((event.message&keyCodeMask)>>8
378 event.modifiers, &keysym, 1));
379 }
380 break;
381 case keyUp: {
382 SDL_keysym keysym;
383
384 SDL_PrivateKeyboard(SDL_RELEASED,
385 TranslateKey((event.message&keyCodeMask)>>8
386 event.modifiers, &keysym, 0));
387 }
388 break;
389 #endif
390 case updateEvt: {
391 BeginUpdate(SDL_Window);
392 if ( (SDL_VideoSurface->flags & SDL_HWSURFACE) ==
393 SDL_SWSURFACE ) {
394 SDL_UpdateRect(SDL_VideoSurface, 0, 0, 0, 0);
395 }
396 EndUpdate(SDL_Window);
397 }
398 /* If this was an update event for the SIOUX console, we return 0
399 in order to stop an endless series of updates being triggered.
400 */
401 if ( (WindowRef) event.message != SDL_Window ) {
402 return 0;
403 }
404 break;
405 case activateEvt: {
406 Mac_HandleActivate(!!(event.modifiers & activeFlag));
407 }
408 break;
409 case diskEvt: {
410 #if TARGET_API_MAC_CARBON
411 /* What are we supposed to do? */;
412 #else
413 if ( ((event.message>>16)&0xFFFF) != noErr ) {
414 Point spot;
415 SetPt(&spot, 0x0070, 0x0050);
416 DIBadMount(spot, event.message);
417 }
418 #endif
419 }
420 break;
421 case osEvt: {
422 switch ((event.message>>24) & 0xFF) {
423 #if 0 /* Handled above the switch statement */
424 case mouseMovedMessage: {
425 myGlobalToLocal(this, &event.where);
426 SDL_PrivateMouseMotion(0, 0,
427 event.where.h, event.where.v);
428 }
429 break;
430 #endif /* 0 */
431 case suspendResumeMessage: {
432 Mac_HandleActivate(!!(event.message & resumeFlag));
433 }
434 break;
435 }
436 }
437 break;
438 default: {
439 ;
440 }
441 break;
442 }
443 return (event.what != nullEvent);
444 }
445
446
447 void Mac_PumpEvents(_THIS)
448 {
449 /* Process pending MacOS events */
450 while ( Mac_HandleEvents(this, 0) ) {
451 /* Loop and check again */;
452 }
453 }
454
455 void Mac_InitOSKeymap(_THIS)
456 {
457 int i;
458
459 /* Map the MAC keysyms */
460 for ( i=0; i<SDL_TABLESIZE(MAC_keymap); ++i )
461 MAC_keymap[i] = SDLK_UNKNOWN;
462
463 /* Wierd, these keys are on my iBook under MacOS X */
464 MAC_keymap[MK_IBOOK_ENTER] = SDLK_KP_ENTER;
465 MAC_keymap[MK_IBOOK_RIGHT] = SDLK_RIGHT;
466 MAC_keymap[MK_IBOOK_DOWN] = SDLK_DOWN;
467 MAC_keymap[MK_IBOOK_UP] = SDLK_UP;
468 MAC_keymap[MK_IBOOK_LEFT] = SDLK_LEFT;
469
470 /* Defined MAC_* constants */
471 MAC_keymap[MK_ESCAPE] = SDLK_ESCAPE;
472 MAC_keymap[MK_F1] = SDLK_F1;
473 MAC_keymap[MK_F2] = SDLK_F2;
474 MAC_keymap[MK_F3] = SDLK_F3;
475 MAC_keymap[MK_F4] = SDLK_F4;
476 MAC_keymap[MK_F5] = SDLK_F5;
477 MAC_keymap[MK_F6] = SDLK_F6;
478 MAC_keymap[MK_F7] = SDLK_F7;
479 MAC_keymap[MK_F8] = SDLK_F8;
480 MAC_keymap[MK_F9] = SDLK_F9;
481 MAC_keymap[MK_F10] = SDLK_F10;
482 MAC_keymap[MK_F11] = SDLK_F11;
483 MAC_keymap[MK_F12] = SDLK_F12;
484 MAC_keymap[MK_PRINT] = SDLK_PRINT;
485 MAC_keymap[MK_SCROLLOCK] = SDLK_SCROLLOCK;
486 MAC_keymap[MK_PAUSE] = SDLK_PAUSE;
487 MAC_keymap[MK_POWER] = SDLK_POWER;
488 MAC_keymap[MK_BACKQUOTE] = SDLK_BACKQUOTE;
489 MAC_keymap[MK_1] = SDLK_1;
490 MAC_keymap[MK_2] = SDLK_2;
491 MAC_keymap[MK_3] = SDLK_3;
492 MAC_keymap[MK_4] = SDLK_4;
493 MAC_keymap[MK_5] = SDLK_5;
494 MAC_keymap[MK_6] = SDLK_6;
495 MAC_keymap[MK_7] = SDLK_7;
496 MAC_keymap[MK_8] = SDLK_8;
497 MAC_keymap[MK_9] = SDLK_9;
498 MAC_keymap[MK_0] = SDLK_0;
499 MAC_keymap[MK_MINUS] = SDLK_MINUS;
500 MAC_keymap[MK_EQUALS] = SDLK_EQUALS;
501 MAC_keymap[MK_BACKSPACE] = SDLK_BACKSPACE;
502 MAC_keymap[MK_INSERT] = SDLK_INSERT;
503 MAC_keymap[MK_HOME] = SDLK_HOME;
504 MAC_keymap[MK_PAGEUP] = SDLK_PAGEUP;
505 MAC_keymap[MK_NUMLOCK] = SDLK_NUMLOCK;
506 MAC_keymap[MK_KP_EQUALS] = SDLK_KP_EQUALS;
507 MAC_keymap[MK_KP_DIVIDE] = SDLK_KP_DIVIDE;
508 MAC_keymap[MK_KP_MULTIPLY] = SDLK_KP_MULTIPLY;
509 MAC_keymap[MK_TAB] = SDLK_TAB;
510 MAC_keymap[MK_q] = SDLK_q;
511 MAC_keymap[MK_w] = SDLK_w;
512 MAC_keymap[MK_e] = SDLK_e;
513 MAC_keymap[MK_r] = SDLK_r;
514 MAC_keymap[MK_t] = SDLK_t;
515 MAC_keymap[MK_y] = SDLK_y;
516 MAC_keymap[MK_u] = SDLK_u;
517 MAC_keymap[MK_i] = SDLK_i;
518 MAC_keymap[MK_o] = SDLK_o;
519 MAC_keymap[MK_p] = SDLK_p;
520 MAC_keymap[MK_LEFTBRACKET] = SDLK_LEFTBRACKET;
521 MAC_keymap[MK_RIGHTBRACKET] = SDLK_RIGHTBRACKET;
522 MAC_keymap[MK_BACKSLASH] = SDLK_BACKSLASH;
523 MAC_keymap[MK_DELETE] = SDLK_DELETE;
524 MAC_keymap[MK_END] = SDLK_END;
525 MAC_keymap[MK_PAGEDOWN] = SDLK_PAGEDOWN;
526 MAC_keymap[MK_KP7] = SDLK_KP7;
527 MAC_keymap[MK_KP8] = SDLK_KP8;
528 MAC_keymap[MK_KP9] = SDLK_KP9;
529 MAC_keymap[MK_KP_MINUS] = SDLK_KP_MINUS;
530 MAC_keymap[MK_CAPSLOCK] = SDLK_CAPSLOCK;
531 MAC_keymap[MK_a] = SDLK_a;
532 MAC_keymap[MK_s] = SDLK_s;
533 MAC_keymap[MK_d] = SDLK_d;
534 MAC_keymap[MK_f] = SDLK_f;
535 MAC_keymap[MK_g] = SDLK_g;
536 MAC_keymap[MK_h] = SDLK_h;
537 MAC_keymap[MK_j] = SDLK_j;
538 MAC_keymap[MK_k] = SDLK_k;
539 MAC_keymap[MK_l] = SDLK_l;
540 MAC_keymap[MK_SEMICOLON] = SDLK_SEMICOLON;
541 MAC_keymap[MK_QUOTE] = SDLK_QUOTE;
542 MAC_keymap[MK_RETURN] = SDLK_RETURN;
543 MAC_keymap[MK_KP4] = SDLK_KP4;
544 MAC_keymap[MK_KP5] = SDLK_KP5;
545 MAC_keymap[MK_KP6] = SDLK_KP6;
546 MAC_keymap[MK_KP_PLUS] = SDLK_KP_PLUS;
547 MAC_keymap[MK_LSHIFT] = SDLK_LSHIFT;
548 MAC_keymap[MK_z] = SDLK_z;
549 MAC_keymap[MK_x] = SDLK_x;
550 MAC_keymap[MK_c] = SDLK_c;
551 MAC_keymap[MK_v] = SDLK_v;
552 MAC_keymap[MK_b] = SDLK_b;
553 MAC_keymap[MK_n] = SDLK_n;
554 MAC_keymap[MK_m] = SDLK_m;
555 MAC_keymap[MK_COMMA] = SDLK_COMMA;
556 MAC_keymap[MK_PERIOD] = SDLK_PERIOD;
557 MAC_keymap[MK_SLASH] = SDLK_SLASH;
558 #if 0 /* These are the same as the left versions - use left by default */
559 MAC_keymap[MK_RSHIFT] = SDLK_RSHIFT;
560 #endif
561 MAC_keymap[MK_UP] = SDLK_UP;
562 MAC_keymap[MK_KP1] = SDLK_KP1;
563 MAC_keymap[MK_KP2] = SDLK_KP2;
564 MAC_keymap[MK_KP3] = SDLK_KP3;
565 MAC_keymap[MK_KP_ENTER] = SDLK_KP_ENTER;
566 MAC_keymap[MK_LCTRL] = SDLK_LCTRL;
567 MAC_keymap[MK_LALT] = SDLK_LALT;
568 MAC_keymap[MK_LMETA] = SDLK_LMETA;
569 MAC_keymap[MK_SPACE] = SDLK_SPACE;
570 #if 0 /* These are the same as the left versions - use left by default */
571 MAC_keymap[MK_RMETA] = SDLK_RMETA;
572 MAC_keymap[MK_RALT] = SDLK_RALT;
573 MAC_keymap[MK_RCTRL] = SDLK_RCTRL;
574 #endif
575 MAC_keymap[MK_LEFT] = SDLK_LEFT;
576 MAC_keymap[MK_DOWN] = SDLK_DOWN;
577 MAC_keymap[MK_RIGHT] = SDLK_RIGHT;
578 MAC_keymap[MK_KP0] = SDLK_KP0;
579 MAC_keymap[MK_KP_PERIOD] = SDLK_KP_PERIOD;
580 }
581
582 static SDL_keysym *TranslateKey(int scancode, int modifiers,
583 SDL_keysym *keysym, int pressed)
584 {
585 /* Set the keysym information */
586 keysym->scancode = scancode;
587 keysym->sym = MAC_keymap[keysym->scancode];
588 keysym->mod = KMOD_NONE;
589 keysym->unicode = 0;
590 if ( pressed && SDL_TranslateUNICODE ) {
591 static unsigned long state = 0;
592 static Ptr keymap = nil;
593 Ptr new_keymap;
594
595 /* Get the current keyboard map resource */
596 new_keymap = (Ptr)GetScriptManagerVariable(smKCHRCache);
597 if ( new_keymap != keymap ) {
598 keymap = new_keymap;
599 state = 0;
600 }
601 keysym->unicode = KeyTranslate(keymap,
602 keysym->scancode|modifiers, &state) & 0xFFFF;
603 }
604 return(keysym);
605 }
606
607 void Mac_InitEvents(_THIS)
608 {
609 /* Create apple menu bar */
610 apple_menu = GetMenu(mApple);
611 if ( apple_menu != nil ) {
612 AppendResMenu(apple_menu, 'DRVR');
613 InsertMenu(apple_menu, 0);
614 }
615 DrawMenuBar();
616
617 /* Get rid of spurious events at startup */
618 FlushEvents(everyEvent, 0);
619
620 /* Allow every event but keyrepeat */
621 SetEventMask(everyEvent - autoKeyMask);
622 }
623
624 void Mac_QuitEvents(_THIS)
625 {
626 ClearMenuBar();
627 if ( apple_menu != nil ) {
628 ReleaseResource((char **)apple_menu);
629 }
630
631 /* Clean up pending events */
632 FlushEvents(everyEvent, 0);
633 }
634
635 static void Mac_DoAppleMenu(_THIS, long choice)
636 {
637 #if !TARGET_API_MAC_CARBON /* No Apple menu in OS X */
638 short menu, item;
639
640 item = (choice&0xFFFF);
641 choice >>= 16;
642 menu = (choice&0xFFFF);
643
644 switch (menu) {
645 case mApple: {
646 switch (item) {
647 case iAbout: {
648 /* Run the about box */;
649 }
650 break;
651 default: {
652 Str255 name;
653
654 GetMenuItemText(apple_menu, item, name);
655 OpenDeskAcc(name);
656 }
657 break;
658 }
659 }
660 break;
661 default: {
662 /* Ignore other menus */;
663 }
664 }
665 #endif /* !TARGET_API_MAC_CARBON */
666 }
667
668 #if !TARGET_API_MAC_CARBON
669 /* Since we don't initialize QuickDraw, we need to get a pointer to qd */
670 QDGlobals *theQD = NULL;
671
672 /* Exported to the macmain code */
673 void SDL_InitQuickDraw(struct QDGlobals *the_qd)
674 {
675 theQD = the_qd;
676 }
677 #endif