Skip to content

Latest commit

 

History

History
676 lines (622 loc) · 17.4 KB

SDL_macevents.c

File metadata and controls

676 lines (622 loc) · 17.4 KB
 
Apr 26, 2001
Apr 26, 2001
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
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997, 1998, 1999, 2000, 2001 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@devolution.com
*/
#ifdef SAVE_RCSID
static char rcsid =
"@(#) $Id$";
#endif
#include <stdio.h>
#if TARGET_API_MAC_CARBON
#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_error.h"
#include "SDL_syswm.h"
#include "SDL_events_c.h"
#include "SDL_cursor_c.h"
#include "SDL_sysevents.h"
#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 */
#define mApple 128 /* Apple menu resource */
#define iAbout 1 /* About menu item */
/* Functions to handle the About menu */
static void Mac_DoAppleMenu(_THIS, long item);
/* The translation table from a macintosh key scancode to a SDL keysym */
static SDLKey MAC_keymap[256];
static SDL_keysym *TranslateKey(int scancode, int modifiers,
SDL_keysym *keysym, int pressed);
/* Handle activation and deactivation -- returns whether an event was posted */
static int Mac_HandleActivate(int activate)
{
if ( activate ) {
/* Show the current SDL application cursor */
SDL_SetCursor(NULL);
/* put our mask back case it changed during context switch */
Sep 4, 2001
Sep 4, 2001
75
SetEventMask(everyEvent & ~autoKeyMask);
Apr 26, 2001
Apr 26, 2001
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
} else {
#if TARGET_API_MAC_CARBON
{ Cursor cursor;
SetCursor(GetQDGlobalsArrow(&cursor));
}
#else
SetCursor(&theQD->arrow);
#endif
if ( ! Mac_cursor_showing ) {
ShowCursor();
Mac_cursor_showing = 1;
}
}
return(SDL_PrivateAppActive(activate, SDL_APPINPUTFOCUS));
}
static void myGlobalToLocal(_THIS, Point *pt)
{
if ( SDL_VideoSurface && !(SDL_VideoSurface->flags&SDL_FULLSCREEN) ) {
GrafPtr saveport;
GetPort(&saveport);
#if TARGET_API_MAC_CARBON
SetPort(GetWindowPort(SDL_Window));
#else
SetPort(SDL_Window);
#endif
GlobalToLocal(pt);
SetPort(saveport);
}
}
/* The main MacOS event handler */
static int Mac_HandleEvents(_THIS, int wait4it)
{
Aug 19, 2001
Aug 19, 2001
110
static int mouse_button = 1;
Apr 26, 2001
Apr 26, 2001
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
int i;
EventRecord event;
#if TARGET_API_MAC_CARBON
/* There's no GetOSEvent() in the Carbon API. *sigh* */
#define cooperative_multitasking 1
#else
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;
}
#endif
/* 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;
}
WaitNextEvent(everyEvent, &event, wait_time, nil);
} else {
#if ! TARGET_API_MAC_CARBON
GetOSEvent(everyEvent, &event);
#endif
}
#if TARGET_API_MAC_CARBON
/* for some reason, event.where isn't set ? */
GetGlobalMouse ( &event.where );
#endif
Aug 19, 2001
Aug 19, 2001
152
Apr 26, 2001
Apr 26, 2001
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
/* Check for mouse motion */
if ( (event.where.h != last_where.h) ||
(event.where.v != last_where.v) ) {
Point pt;
pt = last_where = event.where;
myGlobalToLocal(this, &pt);
SDL_PrivateMouseMotion(0, 0, pt.h, pt.v);
}
/* Check the current state of the keyboard */
if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) {
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 },
#endif /* 0 */
{ 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;
}
SDL_PrivateKeyboard(mode, &keysym);
}
}
/* Save state for next time */
last_mods = mod;
}
/* Check for normal event keys, but we have to scan the
actual keyboard state because on MacOS X a keydown event
is immediately followed by a keyup event.
*/
GetKeys(keys);
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;
#ifdef DEBUG_KEYBOARD
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]);
#endif
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 */
#ifdef DEBUG_KEYBOARD
fprintf(stderr,"Scancode: 0x%2.2X\n",i);
#endif
SDL_PrivateKeyboard(new_bit,
TranslateKey(i, event.modifiers,
&keysym, new_bit));
}
}
/* 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;
area = FindWindow(event.where, &win);
/* Support switching between the SIOUX console
and SDL_Window by clicking in the window.
*/
if ( win && (win != FrontWindow()) ) {
SelectWindow(win);
}
switch (area) {
case inMenuBar: /* Only the apple menu exists */
Mac_DoAppleMenu(this, MenuSelect(event.where));
HiliteMenu(0);
break;
case inDrag:
#if TARGET_API_MAC_CARBON
DragWindow(win, event.where, NULL);
#else
DragWindow(win, event.where, &theQD->screenBits.bounds);
#endif
break;
case inGoAway:
if ( TrackGoAway(win, event.where) ) {
SDL_PrivateQuit();
}
break;
case inContent:
myGlobalToLocal(this, &event.where);
/* Treat command-click as right mouse button */
if ( event.modifiers & optionKey ) {
Aug 19, 2001
Aug 19, 2001
286
287
288
mouse_button = 2;
} else if ( event.modifiers & cmdKey ) {
mouse_button = 3;
Apr 26, 2001
Apr 26, 2001
289
} else {
Aug 19, 2001
Aug 19, 2001
290
mouse_button = 1;
Apr 26, 2001
Apr 26, 2001
291
}
Aug 19, 2001
Aug 19, 2001
292
293
SDL_PrivateMouseButton(SDL_PRESSED,
mouse_button, event.where.h, event.where.v);
Apr 26, 2001
Apr 26, 2001
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
break;
case inGrow: {
int newSize;
/* Don't allow resize if video mode isn't resizable */
if ( ! SDL_PublicSurface ||
! (SDL_PublicSurface->flags & SDL_RESIZABLE) ) {
break;
}
#if TARGET_API_MAC_CARBON
newSize = GrowWindow(win, event.where, NULL);
#else
newSize = GrowWindow(win, event.where, &theQD->screenBits.bounds);
#endif
if ( newSize ) {
#if !TARGET_API_MAC_CARBON
EraseRect ( &theQD->screenBits.bounds );
#endif
SizeWindow ( win, LoWord (newSize), HiWord (newSize), 1 );
SDL_PrivateResize ( LoWord (newSize), HiWord (newSize) );
}
} break;
case inZoomIn:
case inZoomOut:
if ( TrackBox (win, event.where, area )) {
Rect rect;
#if !TARGET_API_MAC_CARBON
EraseRect ( &theQD->screenBits.bounds );
#endif
ZoomWindow ( win, area, 0);
if ( area == inZoomIn ) {
GetWindowUserState(SDL_Window, &rect);
} else {
GetWindowStandardState(SDL_Window, &rect);
}
SDL_PrivateResize (rect.right-rect.left,
rect.bottom-rect.top);
}
break;
#if TARGET_API_MAC_CARBON
case inCollapseBox:
if ( TrackBox (win, event.where, area )) {
if ( IsWindowCollapsable(win) ) {
CollapseWindow (win, !IsWindowCollapsed(win));
Aug 19, 2001
Aug 19, 2001
338
/* There should be something done like in inGrow case, but... */
Apr 26, 2001
Apr 26, 2001
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
}
}
break;
#endif /* TARGET_API_MAC_CARBON */
case inSysWindow:
#if TARGET_API_MAC_CARBON
/* Never happens in Carbon? */
#else
SystemClick(&event, win);
#endif
break;
default:
break;
}
}
break;
case mouseUp: {
myGlobalToLocal(this, &event.where);
Aug 19, 2001
Aug 19, 2001
357
358
359
360
361
362
363
364
/* 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.
*/
SDL_PrivateMouseButton(SDL_RELEASED,
mouse_button, event.where.h, event.where.v);
Apr 26, 2001
Apr 26, 2001
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
}
break;
#if 0 /* Handled above the switch statement */
case keyDown: {
SDL_keysym keysym;
SDL_PrivateKeyboard(SDL_PRESSED,
TranslateKey((event.message&keyCodeMask)>>8
event.modifiers, &keysym, 1));
}
break;
case keyUp: {
SDL_keysym keysym;
SDL_PrivateKeyboard(SDL_RELEASED,
TranslateKey((event.message&keyCodeMask)>>8
event.modifiers, &keysym, 0));
}
break;
#endif
case updateEvt: {
BeginUpdate(SDL_Window);
if ( (SDL_VideoSurface->flags & SDL_HWSURFACE) ==
SDL_SWSURFACE ) {
SDL_UpdateRect(SDL_VideoSurface, 0, 0, 0, 0);
}
EndUpdate(SDL_Window);
}
/* 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: {
Mac_HandleActivate(!!(event.modifiers & activeFlag));
}
break;
case diskEvt: {
#if TARGET_API_MAC_CARBON
/* What are we supposed to do? */;
#else
if ( ((event.message>>16)&0xFFFF) != noErr ) {
Point spot;
SetPt(&spot, 0x0070, 0x0050);
DIBadMount(spot, event.message);
}
#endif
}
break;
case osEvt: {
switch ((event.message>>24) & 0xFF) {
#if 0 /* Handled above the switch statement */
case mouseMovedMessage: {
myGlobalToLocal(this, &event.where);
SDL_PrivateMouseMotion(0, 0,
event.where.h, event.where.v);
}
break;
#endif /* 0 */
case suspendResumeMessage: {
Mac_HandleActivate(!!(event.message & resumeFlag));
}
break;
}
}
break;
default: {
;
}
break;
}
return (event.what != nullEvent);
}
void Mac_PumpEvents(_THIS)
{
/* Process pending MacOS events */
while ( Mac_HandleEvents(this, 0) ) {
/* Loop and check again */;
}
}
void Mac_InitOSKeymap(_THIS)
{
int i;
/* Map the MAC keysyms */
for ( i=0; i<SDL_TABLESIZE(MAC_keymap); ++i )
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;
#endif
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;
#endif
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;
Apr 28, 2001
Apr 28, 2001
568
569
570
571
572
573
574
575
576
577
578
#if defined(__APPLE__) && defined(__MACH__)
/* Wierd, these keys are on my iBook under MacOS 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;
#endif /* MacOS X */
Apr 26, 2001
Apr 26, 2001
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
}
static SDL_keysym *TranslateKey(int scancode, int modifiers,
SDL_keysym *keysym, int pressed)
{
/* 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 */
new_keymap = (Ptr)GetScriptManagerVariable(smKCHRCache);
if ( new_keymap != keymap ) {
keymap = new_keymap;
state = 0;
}
keysym->unicode = KeyTranslate(keymap,
keysym->scancode|modifiers, &state) & 0xFFFF;
}
return(keysym);
}
void Mac_InitEvents(_THIS)
{
/* Create apple menu bar */
apple_menu = GetMenu(mApple);
if ( apple_menu != nil ) {
AppendResMenu(apple_menu, 'DRVR');
InsertMenu(apple_menu, 0);
}
DrawMenuBar();
/* Get rid of spurious events at startup */
FlushEvents(everyEvent, 0);
/* Allow every event but keyrepeat */
Sep 4, 2001
Sep 4, 2001
620
SetEventMask(everyEvent & ~autoKeyMask);
Apr 26, 2001
Apr 26, 2001
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
}
void Mac_QuitEvents(_THIS)
{
ClearMenuBar();
if ( apple_menu != nil ) {
ReleaseResource((char **)apple_menu);
}
/* Clean up pending events */
FlushEvents(everyEvent, 0);
}
static void Mac_DoAppleMenu(_THIS, long choice)
{
#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;
GetMenuItemText(apple_menu, item, name);
OpenDeskAcc(name);
}
break;
}
}
break;
default: {
/* Ignore other menus */;
}
}
#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;
/* Exported to the macmain code */
void SDL_InitQuickDraw(struct QDGlobals *the_qd)
{
theQD = the_qd;
}
#endif