Mercurial > sdl-ios-xcode
annotate src/video/maccommon/SDL_macevents.c @ 4139:568c9b3c0167 SDL-1.2
* Added configure option --enable-screensaver, to allow enabling the screensaver by default.
* Use XResetScreenSaver() instead of disabling screensaver entirely.
Full discussion summary from Erik on the SDL mailing list:
Current behaviour
=================
SDL changes the user's display power management settings without
permission from the user and without telling the user.
The interface that it uses to do so is DPMSDisable/DPMSEnable, which
should only ever be used by configuration utilities like KControl, never
by normal application programs, let alone by the libraries that they
use. Using an interface that is not at all intended for what SDL tries
to achieve means that it will not work as it should. Firstly, the power
management is completely disabled during the whole lifetime of the SDL
program, not only when it should be. Secondly, it makes SDL
non-reentrant, meaning that things will break when multiple SDL programs
are clients of the same X server simultaneously. Thirdly, no cleanup
mechanism ensures that the setting is restored if the client does not do
that (for example if it crashes).
In addition to that, this interface is broken on xorg,
[http://bugs.freedesktop.org/show_bug.cgi?id=13962], so what SDL tries
to do does not work at all on that implementation of the X Window
System. (The reason that the DPMSEnable works in KControl is that it
calls DPMSSetTimeout immediately after,
[http://websvn.kde.org/tags/KDE/3.5.9/kdebase/kcontrol/energy/energy.cpp?annotate=774532#l343]).
The problems that the current behaviour causes
==============================================
1. Information leak. When the user is away, someone might see what the
user has on the display when the user counts on the screensaver
preventing this. This does not even require physical access to the
workstation, it is enough to see it from a distance.
2. Draining battery. An SDL program that runs on a laptop will quickly
drain the battery while the user is away. The system will soon shut down
and require recharging before being usable again, while it should in
fact have consumed very little energy if the user's settings would have
been obeyed.
3. Wasting energy. Even if battery issues are not considered, energy as
such is wasted.
4. Display wear. The display may be worn out.
The problems that the current behaviour tries to solve
======================================================
1. Preventing screensaver while playing movies.
Many SDL applications are media players. They have reasons to prevent
screensavers from being activated while a movie is being played. When a
user clicks on the play button it can be interpreted as saying "play
this movie, but do not turn off the display while playing it, because I
will watch it even though I do not interact with the system".
2. Preventing screensaver when some input bypasses X.
Sometimes SDL uses input from another source than the X server, so
that the X server is bypassed. This obviously breaks the screensaver
handling. SDL tries to work around that.
3. Preventing screensaver when all input bypasses X.
There is something called Direct Graphics Access mode, where a
program takes control of both the display and the input devices from the
X server. This obviously means that the X server can not handle the
screensaver alone, since screensaver handling depends on input handling.
SDL does not do what it should to help the X server to handle the
screensaver. Nor does SDL take care of screeensaver handling itself. SDL
simply disables the screensaver completely.
How the problems should be solved
=================================
The correct way for an application program to prevent the screensaver
under X is to call XResetScreenSaver. This was recently discovered and
implemented by the mplayer developers,
[http://svn.mplayerhq.hu/mplayer?view=rev&revision=25637]. SDL needs to
wrap this in an API call (SDL_ResetScreenSaver) and implement it for the
other video targets (if they do not have a corresponding call, SDL
should do what it takes on that particular target, for example sending
fake key events).
1. When a movie is played, the player should reset the screensaver when
the animation is advanced to a new frame. The same applies to anything
similar, like slideshows.
2. When the X server is handling input, it must handle all input
(keyboards, mice, gamepads, ...). This is necessary, not only to be able
to handle the screensaver, but also so that it can send the events to
the correct (the currently active) client. If there is an input device
that the X server can not handle for some reason (such as lack of Plug
and Play capability), the program that handles the device as a
workaround must simulate what would happen if the X server would have
handled the device, by calling XResetScreenSaver when input is received
from the device.
3. When the X server is not handling the input, it depends on the
program that does to call XResetScreenSaver whenever an input event
occurs. Alternatively the program must handle the screensaver countdown
internally and call XActivateScreenSaver.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Fri, 29 Feb 2008 13:55:44 +0000 |
| parents | f19931785c42 |
| children | a1b03ba2fcd0 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
3 Copyright (C) 1997-2006 Sam Lantinga |
| 0 | 4 |
| 5 This library is free software; you can redistribute it and/or | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
6 modify it under the terms of the GNU Lesser General Public |
| 0 | 7 License as published by the Free Software Foundation; either |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
8 version 2.1 of the License, or (at your option) any later version. |
| 0 | 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 | |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
13 Lesser General Public License for more details. |
| 0 | 14 |
|
1312
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
15 You should have received a copy of the GNU Lesser General Public |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
16 License along with this library; if not, write to the Free Software |
|
c9b51268668f
Updated copyright information and removed rcs id lines (problematic in branch merges)
Sam Lantinga <slouken@libsdl.org>
parents:
1133
diff
changeset
|
17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 0 | 18 |
| 19 Sam Lantinga | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
198
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
|
1402
d910939febfa
Use consistent identifiers for the various platforms we support.
Sam Lantinga <slouken@libsdl.org>
parents:
1379
diff
changeset
|
22 #include "SDL_config.h" |
| 0 | 23 |
| 24 #include <stdio.h> | |
| 25 | |
|
1133
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
26 #if defined(__APPLE__) && defined(__MACH__) |
|
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
27 #include <Carbon/Carbon.h> |
|
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
28 #elif TARGET_API_MAC_CARBON && (UNIVERSAL_INTERFACES_VERSION > 0x0335) |
| 0 | 29 #include <Carbon.h> |
| 30 #else | |
| 31 #include <Script.h> | |
| 32 #include <LowMem.h> | |
| 33 #include <Devices.h> | |
| 34 #include <DiskInit.h> | |
| 35 #include <ToolUtils.h> | |
| 36 #endif | |
| 37 | |
| 38 #include "SDL_events.h" | |
| 39 #include "SDL_video.h" | |
| 40 #include "SDL_syswm.h" | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
41 #include "../../events/SDL_events_c.h" |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
42 #include "../../events/SDL_sysevents.h" |
|
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
43 #include "../SDL_cursor_c.h" |
| 0 | 44 #include "SDL_macevents_c.h" |
| 45 #include "SDL_mackeys.h" | |
| 46 #include "SDL_macmouse_c.h" | |
| 47 | |
| 48 /* Define this to be able to collapse SDL windows. | |
| 49 #define USE_APPEARANCE_MANAGER | |
| 50 */ | |
| 51 | |
| 52 /* Macintosh resource constants */ | |
| 53 #define mApple 128 /* Apple menu resource */ | |
| 54 #define iAbout 1 /* About menu item */ | |
| 55 | |
| 56 /* Functions to handle the About menu */ | |
| 57 static void Mac_DoAppleMenu(_THIS, long item); | |
| 58 | |
| 59 /* The translation table from a macintosh key scancode to a SDL keysym */ | |
| 60 static SDLKey MAC_keymap[256]; | |
| 61 static SDL_keysym *TranslateKey(int scancode, int modifiers, | |
| 62 SDL_keysym *keysym, int pressed); | |
| 63 | |
| 64 /* Handle activation and deactivation -- returns whether an event was posted */ | |
| 65 static int Mac_HandleActivate(int activate) | |
| 66 { | |
| 67 if ( activate ) { | |
| 68 /* Show the current SDL application cursor */ | |
| 69 SDL_SetCursor(NULL); | |
| 70 | |
| 71 /* put our mask back case it changed during context switch */ | |
|
168
e92aa316c517
Added Max's patches for building MacOS X apps on command line
Sam Lantinga <slouken@libsdl.org>
parents:
155
diff
changeset
|
72 SetEventMask(everyEvent & ~autoKeyMask); |
| 0 | 73 } else { |
| 74 #if TARGET_API_MAC_CARBON | |
| 75 { Cursor cursor; | |
| 76 SetCursor(GetQDGlobalsArrow(&cursor)); | |
| 77 } | |
| 78 #else | |
| 79 SetCursor(&theQD->arrow); | |
| 80 #endif | |
| 81 if ( ! Mac_cursor_showing ) { | |
| 82 ShowCursor(); | |
| 83 Mac_cursor_showing = 1; | |
| 84 } | |
| 85 } | |
| 86 return(SDL_PrivateAppActive(activate, SDL_APPINPUTFOCUS)); | |
| 87 } | |
| 88 | |
| 89 static void myGlobalToLocal(_THIS, Point *pt) | |
| 90 { | |
| 91 if ( SDL_VideoSurface && !(SDL_VideoSurface->flags&SDL_FULLSCREEN) ) { | |
| 92 GrafPtr saveport; | |
| 93 GetPort(&saveport); | |
| 94 #if TARGET_API_MAC_CARBON | |
| 95 SetPort(GetWindowPort(SDL_Window)); | |
| 96 #else | |
| 97 SetPort(SDL_Window); | |
| 98 #endif | |
| 99 GlobalToLocal(pt); | |
| 100 SetPort(saveport); | |
| 101 } | |
| 102 } | |
| 103 | |
| 104 /* The main MacOS event handler */ | |
| 105 static int Mac_HandleEvents(_THIS, int wait4it) | |
| 106 { | |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
107 static int mouse_button = 1; |
| 0 | 108 int i; |
| 109 EventRecord event; | |
| 110 | |
| 111 #if TARGET_API_MAC_CARBON | |
| 112 /* There's no GetOSEvent() in the Carbon API. *sigh* */ | |
| 113 #define cooperative_multitasking 1 | |
| 114 #else | |
| 115 int cooperative_multitasking; | |
| 116 /* If we're running fullscreen, we can hog the MacOS events, | |
| 117 otherwise we had better play nicely with the other apps. | |
| 118 */ | |
| 119 if ( this->screen && (this->screen->flags & SDL_FULLSCREEN) ) { | |
| 120 cooperative_multitasking = 0; | |
| 121 } else { | |
| 122 cooperative_multitasking = 1; | |
| 123 } | |
| 124 #endif | |
| 125 | |
| 126 /* If we call WaitNextEvent(), MacOS will check other processes | |
| 127 * and allow them to run, and perform other high-level processing. | |
| 128 */ | |
| 129 if ( cooperative_multitasking || wait4it ) { | |
| 130 UInt32 wait_time; | |
| 131 | |
| 132 /* Are we polling or not? */ | |
| 133 if ( wait4it ) { | |
| 134 wait_time = 2147483647; | |
| 135 } else { | |
| 136 wait_time = 0; | |
| 137 } | |
| 138 WaitNextEvent(everyEvent, &event, wait_time, nil); | |
| 139 } else { | |
| 140 #if ! TARGET_API_MAC_CARBON | |
| 141 GetOSEvent(everyEvent, &event); | |
| 142 #endif | |
| 143 } | |
| 144 | |
| 145 #if TARGET_API_MAC_CARBON | |
| 146 /* for some reason, event.where isn't set ? */ | |
| 147 GetGlobalMouse ( &event.where ); | |
| 148 #endif | |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
149 |
| 0 | 150 /* Check for mouse motion */ |
| 151 if ( (event.where.h != last_where.h) || | |
| 152 (event.where.v != last_where.v) ) { | |
| 153 Point pt; | |
| 154 pt = last_where = event.where; | |
| 155 myGlobalToLocal(this, &pt); | |
| 156 SDL_PrivateMouseMotion(0, 0, pt.h, pt.v); | |
| 157 } | |
| 158 | |
| 159 /* Check the current state of the keyboard */ | |
| 160 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) { | |
| 161 KeyMap keys; | |
|
4069
f19931785c42
An attempt at fixing Bugzilla #454.
Ryan C. Gordon <icculus@icculus.org>
parents:
4068
diff
changeset
|
162 const Uint32 *keysptr = (Uint32 *) &keys; |
|
f19931785c42
An attempt at fixing Bugzilla #454.
Ryan C. Gordon <icculus@icculus.org>
parents:
4068
diff
changeset
|
163 const Uint32 *last_keysptr = (Uint32 *) &last_keys; |
| 0 | 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 | |
| 1621 | 215 actual keyboard state because on Mac OS X a keydown event |
| 0 | 216 is immediately followed by a keyup event. |
| 217 */ | |
| 218 GetKeys(keys); | |
|
3947
0f8a812e2855
Patched to compile on Mac OS X (not that you should necessarily be using this
Ryan C. Gordon <icculus@icculus.org>
parents:
1621
diff
changeset
|
219 if ( (keysptr[0] != last_keysptr[0]) || |
|
0f8a812e2855
Patched to compile on Mac OS X (not that you should necessarily be using this
Ryan C. Gordon <icculus@icculus.org>
parents:
1621
diff
changeset
|
220 (keysptr[1] != last_keysptr[1]) || |
|
0f8a812e2855
Patched to compile on Mac OS X (not that you should necessarily be using this
Ryan C. Gordon <icculus@icculus.org>
parents:
1621
diff
changeset
|
221 (keysptr[2] != last_keysptr[2]) || |
|
0f8a812e2855
Patched to compile on Mac OS X (not that you should necessarily be using this
Ryan C. Gordon <icculus@icculus.org>
parents:
1621
diff
changeset
|
222 (keysptr[3] != last_keysptr[3]) ) { |
| 0 | 223 SDL_keysym keysym; |
| 224 int old_bit, new_bit; | |
| 225 | |
| 226 #ifdef DEBUG_KEYBOARD | |
| 227 fprintf(sterr, "New keys: 0x%x 0x%x 0x%x 0x%x\n", | |
| 228 new_keys[0], new_keys[1], | |
| 229 new_keys[2], new_keys[3]); | |
| 230 #endif | |
| 231 for ( i=0; i<128; ++i ) { | |
| 232 old_bit = (((Uint8 *)last_keys)[i/8]>>(i%8)) & 0x01; | |
| 233 new_bit = (((Uint8 *)keys)[i/8]>>(i%8)) & 0x01; | |
| 234 if ( old_bit != new_bit ) { | |
| 235 /* Post the keyboard event */ | |
| 236 #ifdef DEBUG_KEYBOARD | |
| 237 fprintf(stderr,"Scancode: 0x%2.2X\n",i); | |
| 238 #endif | |
| 239 SDL_PrivateKeyboard(new_bit, | |
| 240 TranslateKey(i, event.modifiers, | |
| 241 &keysym, new_bit)); | |
| 242 } | |
| 243 } | |
| 244 | |
| 245 /* Save state for next time */ | |
| 246 last_keys[0] = keys[0]; | |
| 247 last_keys[1] = keys[1]; | |
| 248 last_keys[2] = keys[2]; | |
| 249 last_keys[3] = keys[3]; | |
| 250 } | |
| 251 } | |
| 252 | |
| 253 /* Handle normal events */ | |
| 254 switch (event.what) { | |
| 255 case mouseDown: { | |
| 256 WindowRef win; | |
| 257 short area; | |
| 258 | |
| 259 area = FindWindow(event.where, &win); | |
| 260 /* Support switching between the SIOUX console | |
| 261 and SDL_Window by clicking in the window. | |
| 262 */ | |
| 263 if ( win && (win != FrontWindow()) ) { | |
| 264 SelectWindow(win); | |
| 265 } | |
| 266 switch (area) { | |
| 267 case inMenuBar: /* Only the apple menu exists */ | |
| 268 Mac_DoAppleMenu(this, MenuSelect(event.where)); | |
| 269 HiliteMenu(0); | |
| 270 break; | |
| 271 case inDrag: | |
| 272 #if TARGET_API_MAC_CARBON | |
| 273 DragWindow(win, event.where, NULL); | |
| 274 #else | |
| 275 DragWindow(win, event.where, &theQD->screenBits.bounds); | |
| 276 #endif | |
| 277 break; | |
| 278 case inGoAway: | |
| 279 if ( TrackGoAway(win, event.where) ) { | |
| 280 SDL_PrivateQuit(); | |
| 281 } | |
| 282 break; | |
| 283 case inContent: | |
| 284 myGlobalToLocal(this, &event.where); | |
| 285 /* Treat command-click as right mouse button */ | |
| 286 if ( event.modifiers & optionKey ) { | |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
287 mouse_button = 2; |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
288 } else if ( event.modifiers & cmdKey ) { |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
289 mouse_button = 3; |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
290 } else { |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
291 mouse_button = 1; |
| 0 | 292 } |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
293 SDL_PrivateMouseButton(SDL_PRESSED, |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
294 mouse_button, event.where.h, event.where.v); |
| 0 | 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)); | |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
339 /* There should be something done like in inGrow case, but... */ |
| 0 | 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); | |
|
155
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
358 /* Release the mouse button we simulated in the last press. |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
359 The drawback of this methos is we cannot press more than |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
360 one button. However, this doesn't matter, since there is |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
361 only a single logical mouse button, even if you have a |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
362 multi-button mouse, this doesn't matter at all. |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
363 */ |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
364 SDL_PrivateMouseButton(SDL_RELEASED, |
|
2d162219f433
Date: Thu, 16 Aug 2001 21:50:51 -0500 (EST)
Sam Lantinga <slouken@libsdl.org>
parents:
10
diff
changeset
|
365 mouse_button, event.where.h, event.where.v); |
| 0 | 366 } |
| 367 break; | |
| 368 #if 0 /* Handled above the switch statement */ | |
| 369 case keyDown: { | |
| 370 SDL_keysym keysym; | |
| 371 | |
| 372 SDL_PrivateKeyboard(SDL_PRESSED, | |
| 373 TranslateKey((event.message&keyCodeMask)>>8 | |
| 374 event.modifiers, &keysym, 1)); | |
| 375 } | |
| 376 break; | |
| 377 case keyUp: { | |
| 378 SDL_keysym keysym; | |
| 379 | |
| 380 SDL_PrivateKeyboard(SDL_RELEASED, | |
| 381 TranslateKey((event.message&keyCodeMask)>>8 | |
| 382 event.modifiers, &keysym, 0)); | |
| 383 } | |
| 384 break; | |
| 385 #endif | |
| 386 case updateEvt: { | |
| 387 BeginUpdate(SDL_Window); | |
|
1361
19418e4422cb
New configure-based build system. Still work in progress, but much improved
Sam Lantinga <slouken@libsdl.org>
parents:
1358
diff
changeset
|
388 #if SDL_VIDEO_OPENGL |
|
774
0c3e00cc9580
Date: Mon, 5 Jan 2004 00:09:36 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
389 if (SDL_VideoSurface->flags & SDL_OPENGL) |
|
0c3e00cc9580
Date: Mon, 5 Jan 2004 00:09:36 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
390 SDL_GL_SwapBuffers(); |
|
0c3e00cc9580
Date: Mon, 5 Jan 2004 00:09:36 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
391 else |
|
0c3e00cc9580
Date: Mon, 5 Jan 2004 00:09:36 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
392 #endif |
| 0 | 393 if ( (SDL_VideoSurface->flags & SDL_HWSURFACE) == |
| 394 SDL_SWSURFACE ) { | |
| 395 SDL_UpdateRect(SDL_VideoSurface, 0, 0, 0, 0); | |
| 396 } | |
| 397 EndUpdate(SDL_Window); | |
| 398 } | |
| 399 /* If this was an update event for the SIOUX console, we return 0 | |
| 400 in order to stop an endless series of updates being triggered. | |
| 401 */ | |
| 402 if ( (WindowRef) event.message != SDL_Window ) { | |
| 403 return 0; | |
| 404 } | |
| 405 break; | |
| 406 case activateEvt: { | |
| 407 Mac_HandleActivate(!!(event.modifiers & activeFlag)); | |
| 408 } | |
| 409 break; | |
| 410 case diskEvt: { | |
| 411 #if TARGET_API_MAC_CARBON | |
| 412 /* What are we supposed to do? */; | |
| 413 #else | |
| 414 if ( ((event.message>>16)&0xFFFF) != noErr ) { | |
| 415 Point spot; | |
| 416 SetPt(&spot, 0x0070, 0x0050); | |
| 417 DIBadMount(spot, event.message); | |
| 418 } | |
| 419 #endif | |
| 420 } | |
| 421 break; | |
| 422 case osEvt: { | |
| 423 switch ((event.message>>24) & 0xFF) { | |
| 424 #if 0 /* Handled above the switch statement */ | |
| 425 case mouseMovedMessage: { | |
| 426 myGlobalToLocal(this, &event.where); | |
| 427 SDL_PrivateMouseMotion(0, 0, | |
| 428 event.where.h, event.where.v); | |
| 429 } | |
| 430 break; | |
| 431 #endif /* 0 */ | |
| 432 case suspendResumeMessage: { | |
| 433 Mac_HandleActivate(!!(event.message & resumeFlag)); | |
| 434 } | |
| 435 break; | |
| 436 } | |
| 437 } | |
| 438 break; | |
| 439 default: { | |
| 440 ; | |
| 441 } | |
| 442 break; | |
| 443 } | |
| 444 return (event.what != nullEvent); | |
| 445 } | |
| 446 | |
| 447 | |
| 448 void Mac_PumpEvents(_THIS) | |
| 449 { | |
| 450 /* Process pending MacOS events */ | |
| 451 while ( Mac_HandleEvents(this, 0) ) { | |
| 452 /* Loop and check again */; | |
| 453 } | |
| 454 } | |
| 455 | |
| 456 void Mac_InitOSKeymap(_THIS) | |
| 457 { | |
|
198
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
458 const void *KCHRPtr; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
459 UInt32 state; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
460 UInt32 value; |
| 0 | 461 int i; |
|
198
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
462 int world = SDLK_WORLD_0; |
| 0 | 463 |
| 464 /* Map the MAC keysyms */ | |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
465 for ( i=0; i<SDL_arraysize(MAC_keymap); ++i ) |
| 0 | 466 MAC_keymap[i] = SDLK_UNKNOWN; |
| 467 | |
| 468 /* Defined MAC_* constants */ | |
| 469 MAC_keymap[MK_ESCAPE] = SDLK_ESCAPE; | |
| 470 MAC_keymap[MK_F1] = SDLK_F1; | |
| 471 MAC_keymap[MK_F2] = SDLK_F2; | |
| 472 MAC_keymap[MK_F3] = SDLK_F3; | |
| 473 MAC_keymap[MK_F4] = SDLK_F4; | |
| 474 MAC_keymap[MK_F5] = SDLK_F5; | |
| 475 MAC_keymap[MK_F6] = SDLK_F6; | |
| 476 MAC_keymap[MK_F7] = SDLK_F7; | |
| 477 MAC_keymap[MK_F8] = SDLK_F8; | |
| 478 MAC_keymap[MK_F9] = SDLK_F9; | |
| 479 MAC_keymap[MK_F10] = SDLK_F10; | |
| 480 MAC_keymap[MK_F11] = SDLK_F11; | |
| 481 MAC_keymap[MK_F12] = SDLK_F12; | |
| 482 MAC_keymap[MK_PRINT] = SDLK_PRINT; | |
| 483 MAC_keymap[MK_SCROLLOCK] = SDLK_SCROLLOCK; | |
| 484 MAC_keymap[MK_PAUSE] = SDLK_PAUSE; | |
| 485 MAC_keymap[MK_POWER] = SDLK_POWER; | |
| 486 MAC_keymap[MK_BACKQUOTE] = SDLK_BACKQUOTE; | |
| 487 MAC_keymap[MK_1] = SDLK_1; | |
| 488 MAC_keymap[MK_2] = SDLK_2; | |
| 489 MAC_keymap[MK_3] = SDLK_3; | |
| 490 MAC_keymap[MK_4] = SDLK_4; | |
| 491 MAC_keymap[MK_5] = SDLK_5; | |
| 492 MAC_keymap[MK_6] = SDLK_6; | |
| 493 MAC_keymap[MK_7] = SDLK_7; | |
| 494 MAC_keymap[MK_8] = SDLK_8; | |
| 495 MAC_keymap[MK_9] = SDLK_9; | |
| 496 MAC_keymap[MK_0] = SDLK_0; | |
| 497 MAC_keymap[MK_MINUS] = SDLK_MINUS; | |
| 498 MAC_keymap[MK_EQUALS] = SDLK_EQUALS; | |
| 499 MAC_keymap[MK_BACKSPACE] = SDLK_BACKSPACE; | |
| 500 MAC_keymap[MK_INSERT] = SDLK_INSERT; | |
| 501 MAC_keymap[MK_HOME] = SDLK_HOME; | |
| 502 MAC_keymap[MK_PAGEUP] = SDLK_PAGEUP; | |
| 503 MAC_keymap[MK_NUMLOCK] = SDLK_NUMLOCK; | |
| 504 MAC_keymap[MK_KP_EQUALS] = SDLK_KP_EQUALS; | |
| 505 MAC_keymap[MK_KP_DIVIDE] = SDLK_KP_DIVIDE; | |
| 506 MAC_keymap[MK_KP_MULTIPLY] = SDLK_KP_MULTIPLY; | |
| 507 MAC_keymap[MK_TAB] = SDLK_TAB; | |
| 508 MAC_keymap[MK_q] = SDLK_q; | |
| 509 MAC_keymap[MK_w] = SDLK_w; | |
| 510 MAC_keymap[MK_e] = SDLK_e; | |
| 511 MAC_keymap[MK_r] = SDLK_r; | |
| 512 MAC_keymap[MK_t] = SDLK_t; | |
| 513 MAC_keymap[MK_y] = SDLK_y; | |
| 514 MAC_keymap[MK_u] = SDLK_u; | |
| 515 MAC_keymap[MK_i] = SDLK_i; | |
| 516 MAC_keymap[MK_o] = SDLK_o; | |
| 517 MAC_keymap[MK_p] = SDLK_p; | |
| 518 MAC_keymap[MK_LEFTBRACKET] = SDLK_LEFTBRACKET; | |
| 519 MAC_keymap[MK_RIGHTBRACKET] = SDLK_RIGHTBRACKET; | |
| 520 MAC_keymap[MK_BACKSLASH] = SDLK_BACKSLASH; | |
| 521 MAC_keymap[MK_DELETE] = SDLK_DELETE; | |
| 522 MAC_keymap[MK_END] = SDLK_END; | |
| 523 MAC_keymap[MK_PAGEDOWN] = SDLK_PAGEDOWN; | |
| 524 MAC_keymap[MK_KP7] = SDLK_KP7; | |
| 525 MAC_keymap[MK_KP8] = SDLK_KP8; | |
| 526 MAC_keymap[MK_KP9] = SDLK_KP9; | |
| 527 MAC_keymap[MK_KP_MINUS] = SDLK_KP_MINUS; | |
| 528 MAC_keymap[MK_CAPSLOCK] = SDLK_CAPSLOCK; | |
| 529 MAC_keymap[MK_a] = SDLK_a; | |
| 530 MAC_keymap[MK_s] = SDLK_s; | |
| 531 MAC_keymap[MK_d] = SDLK_d; | |
| 532 MAC_keymap[MK_f] = SDLK_f; | |
| 533 MAC_keymap[MK_g] = SDLK_g; | |
| 534 MAC_keymap[MK_h] = SDLK_h; | |
| 535 MAC_keymap[MK_j] = SDLK_j; | |
| 536 MAC_keymap[MK_k] = SDLK_k; | |
| 537 MAC_keymap[MK_l] = SDLK_l; | |
| 538 MAC_keymap[MK_SEMICOLON] = SDLK_SEMICOLON; | |
| 539 MAC_keymap[MK_QUOTE] = SDLK_QUOTE; | |
| 540 MAC_keymap[MK_RETURN] = SDLK_RETURN; | |
| 541 MAC_keymap[MK_KP4] = SDLK_KP4; | |
| 542 MAC_keymap[MK_KP5] = SDLK_KP5; | |
| 543 MAC_keymap[MK_KP6] = SDLK_KP6; | |
| 544 MAC_keymap[MK_KP_PLUS] = SDLK_KP_PLUS; | |
| 545 MAC_keymap[MK_LSHIFT] = SDLK_LSHIFT; | |
| 546 MAC_keymap[MK_z] = SDLK_z; | |
| 547 MAC_keymap[MK_x] = SDLK_x; | |
| 548 MAC_keymap[MK_c] = SDLK_c; | |
| 549 MAC_keymap[MK_v] = SDLK_v; | |
| 550 MAC_keymap[MK_b] = SDLK_b; | |
| 551 MAC_keymap[MK_n] = SDLK_n; | |
| 552 MAC_keymap[MK_m] = SDLK_m; | |
| 553 MAC_keymap[MK_COMMA] = SDLK_COMMA; | |
| 554 MAC_keymap[MK_PERIOD] = SDLK_PERIOD; | |
| 555 MAC_keymap[MK_SLASH] = SDLK_SLASH; | |
| 556 #if 0 /* These are the same as the left versions - use left by default */ | |
| 557 MAC_keymap[MK_RSHIFT] = SDLK_RSHIFT; | |
| 558 #endif | |
| 559 MAC_keymap[MK_UP] = SDLK_UP; | |
| 560 MAC_keymap[MK_KP1] = SDLK_KP1; | |
| 561 MAC_keymap[MK_KP2] = SDLK_KP2; | |
| 562 MAC_keymap[MK_KP3] = SDLK_KP3; | |
| 563 MAC_keymap[MK_KP_ENTER] = SDLK_KP_ENTER; | |
| 564 MAC_keymap[MK_LCTRL] = SDLK_LCTRL; | |
| 565 MAC_keymap[MK_LALT] = SDLK_LALT; | |
| 566 MAC_keymap[MK_LMETA] = SDLK_LMETA; | |
| 567 MAC_keymap[MK_SPACE] = SDLK_SPACE; | |
| 568 #if 0 /* These are the same as the left versions - use left by default */ | |
| 569 MAC_keymap[MK_RMETA] = SDLK_RMETA; | |
| 570 MAC_keymap[MK_RALT] = SDLK_RALT; | |
| 571 MAC_keymap[MK_RCTRL] = SDLK_RCTRL; | |
| 572 #endif | |
| 573 MAC_keymap[MK_LEFT] = SDLK_LEFT; | |
| 574 MAC_keymap[MK_DOWN] = SDLK_DOWN; | |
| 575 MAC_keymap[MK_RIGHT] = SDLK_RIGHT; | |
| 576 MAC_keymap[MK_KP0] = SDLK_KP0; | |
| 577 MAC_keymap[MK_KP_PERIOD] = SDLK_KP_PERIOD; | |
|
10
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
578 |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
579 #if defined(__APPLE__) && defined(__MACH__) |
| 1621 | 580 /* Wierd, these keys are on my iBook under Mac OS X |
|
10
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
581 Note that the left arrow keysym is the same as left ctrl!? |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
582 */ |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
583 MAC_keymap[MK_IBOOK_ENTER] = SDLK_KP_ENTER; |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
584 MAC_keymap[MK_IBOOK_RIGHT] = SDLK_RIGHT; |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
585 MAC_keymap[MK_IBOOK_DOWN] = SDLK_DOWN; |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
586 MAC_keymap[MK_IBOOK_UP] = SDLK_UP; |
|
ee3bb7cd06b5
Fixed left arrow on iBook keyboard under MacOS X
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
587 MAC_keymap[MK_IBOOK_LEFT] = SDLK_LEFT; |
| 1621 | 588 #endif /* Mac OS X */ |
|
198
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
589 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
590 /* Up there we setup a static scancode->keysym map. However, it will not |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
591 * work very well on international keyboard. Hence we now query MacOS |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
592 * for its own keymap to adjust our own mapping table. However, this is |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
593 * bascially only useful for ascii char keys. This is also the reason |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
594 * why we keep the static table, too. |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
595 */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
596 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
597 /* Get a pointer to the systems cached KCHR */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
598 KCHRPtr = (void *)GetScriptManagerVariable(smKCHRCache); |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
599 if (KCHRPtr) |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
600 { |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
601 /* Loop over all 127 possible scan codes */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
602 for (i = 0; i < 0x7F; i++) |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
603 { |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
604 /* We pretend a clean start to begin with (i.e. no dead keys active */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
605 state = 0; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
606 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
607 /* Now translate the key code to a key value */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
608 value = KeyTranslate(KCHRPtr, i, &state) & 0xff; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
609 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
610 /* If the state become 0, it was a dead key. We need to translate again, |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
611 passing in the new state, to get the actual key value */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
612 if (state != 0) |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
613 value = KeyTranslate(KCHRPtr, i, &state) & 0xff; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
614 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
615 /* Now we should have an ascii value, or 0. Try to figure out to which SDL symbol it maps */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
616 if (value >= 128) /* Some non-ASCII char, map it to SDLK_WORLD_* */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
617 MAC_keymap[i] = world++; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
618 else if (value >= 32) /* non-control ASCII char */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
619 MAC_keymap[i] = value; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
620 } |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
621 } |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
622 |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
623 /* The keypad codes are re-setup here, because the loop above cannot |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
624 * distinguish between a key on the keypad and a regular key. We maybe |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
625 * could get around this problem in another fashion: NSEvent's flags |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
626 * include a "NSNumericPadKeyMask" bit; we could check that and modify |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
627 * the symbol we return on the fly. However, this flag seems to exhibit |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
628 * some weird behaviour related to the num lock key |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
629 */ |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
630 MAC_keymap[MK_KP0] = SDLK_KP0; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
631 MAC_keymap[MK_KP1] = SDLK_KP1; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
632 MAC_keymap[MK_KP2] = SDLK_KP2; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
633 MAC_keymap[MK_KP3] = SDLK_KP3; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
634 MAC_keymap[MK_KP4] = SDLK_KP4; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
635 MAC_keymap[MK_KP5] = SDLK_KP5; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
636 MAC_keymap[MK_KP6] = SDLK_KP6; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
637 MAC_keymap[MK_KP7] = SDLK_KP7; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
638 MAC_keymap[MK_KP8] = SDLK_KP8; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
639 MAC_keymap[MK_KP9] = SDLK_KP9; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
640 MAC_keymap[MK_KP_MINUS] = SDLK_KP_MINUS; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
641 MAC_keymap[MK_KP_PLUS] = SDLK_KP_PLUS; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
642 MAC_keymap[MK_KP_PERIOD] = SDLK_KP_PERIOD; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
643 MAC_keymap[MK_KP_EQUALS] = SDLK_KP_EQUALS; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
644 MAC_keymap[MK_KP_DIVIDE] = SDLK_KP_DIVIDE; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
645 MAC_keymap[MK_KP_MULTIPLY] = SDLK_KP_MULTIPLY; |
|
49bf25403f5e
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
168
diff
changeset
|
646 MAC_keymap[MK_KP_ENTER] = SDLK_KP_ENTER; |
| 0 | 647 } |
| 648 | |
| 649 static SDL_keysym *TranslateKey(int scancode, int modifiers, | |
| 650 SDL_keysym *keysym, int pressed) | |
| 651 { | |
| 652 /* Set the keysym information */ | |
| 653 keysym->scancode = scancode; | |
| 654 keysym->sym = MAC_keymap[keysym->scancode]; | |
| 655 keysym->mod = KMOD_NONE; | |
| 656 keysym->unicode = 0; | |
| 657 if ( pressed && SDL_TranslateUNICODE ) { | |
| 658 static unsigned long state = 0; | |
| 659 static Ptr keymap = nil; | |
| 660 Ptr new_keymap; | |
| 661 | |
| 662 /* Get the current keyboard map resource */ | |
| 663 new_keymap = (Ptr)GetScriptManagerVariable(smKCHRCache); | |
| 664 if ( new_keymap != keymap ) { | |
| 665 keymap = new_keymap; | |
| 666 state = 0; | |
| 667 } | |
| 668 keysym->unicode = KeyTranslate(keymap, | |
| 669 keysym->scancode|modifiers, &state) & 0xFFFF; | |
| 670 } | |
| 671 return(keysym); | |
| 672 } | |
| 673 | |
| 674 void Mac_InitEvents(_THIS) | |
| 675 { | |
| 676 /* Create apple menu bar */ | |
| 677 apple_menu = GetMenu(mApple); | |
| 678 if ( apple_menu != nil ) { | |
| 679 AppendResMenu(apple_menu, 'DRVR'); | |
| 680 InsertMenu(apple_menu, 0); | |
| 681 } | |
| 682 DrawMenuBar(); | |
| 683 | |
| 684 /* Get rid of spurious events at startup */ | |
| 685 FlushEvents(everyEvent, 0); | |
| 686 | |
| 687 /* Allow every event but keyrepeat */ | |
|
168
e92aa316c517
Added Max's patches for building MacOS X apps on command line
Sam Lantinga <slouken@libsdl.org>
parents:
155
diff
changeset
|
688 SetEventMask(everyEvent & ~autoKeyMask); |
| 0 | 689 } |
| 690 | |
| 691 void Mac_QuitEvents(_THIS) | |
| 692 { | |
| 693 ClearMenuBar(); | |
| 694 if ( apple_menu != nil ) { | |
| 695 ReleaseResource((char **)apple_menu); | |
| 696 } | |
| 697 | |
| 698 /* Clean up pending events */ | |
| 699 FlushEvents(everyEvent, 0); | |
| 700 } | |
| 701 | |
| 702 static void Mac_DoAppleMenu(_THIS, long choice) | |
| 703 { | |
| 704 #if !TARGET_API_MAC_CARBON /* No Apple menu in OS X */ | |
| 705 short menu, item; | |
| 706 | |
| 707 item = (choice&0xFFFF); | |
| 708 choice >>= 16; | |
| 709 menu = (choice&0xFFFF); | |
| 710 | |
| 711 switch (menu) { | |
| 712 case mApple: { | |
| 713 switch (item) { | |
| 714 case iAbout: { | |
| 715 /* Run the about box */; | |
| 716 } | |
| 717 break; | |
| 718 default: { | |
| 719 Str255 name; | |
| 720 | |
| 721 GetMenuItemText(apple_menu, item, name); | |
| 722 OpenDeskAcc(name); | |
| 723 } | |
| 724 break; | |
| 725 } | |
| 726 } | |
| 727 break; | |
| 728 default: { | |
| 729 /* Ignore other menus */; | |
| 730 } | |
| 731 } | |
| 732 #endif /* !TARGET_API_MAC_CARBON */ | |
| 733 } | |
| 734 | |
| 735 #if !TARGET_API_MAC_CARBON | |
| 736 /* Since we don't initialize QuickDraw, we need to get a pointer to qd */ | |
|
3947
0f8a812e2855
Patched to compile on Mac OS X (not that you should necessarily be using this
Ryan C. Gordon <icculus@icculus.org>
parents:
1621
diff
changeset
|
737 struct QDGlobals *theQD = NULL; |
|
1133
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
738 #endif |
| 0 | 739 |
| 740 /* Exported to the macmain code */ | |
| 741 void SDL_InitQuickDraw(struct QDGlobals *the_qd) | |
| 742 { | |
|
1133
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
743 #if !TARGET_API_MAC_CARBON |
| 0 | 744 theQD = the_qd; |
|
1133
609c060fd2a2
The MacOSX Carbon/Cocoa/X11 all in one library patch. Relevant emails:
Ryan C. Gordon <icculus@icculus.org>
parents:
774
diff
changeset
|
745 #endif |
| 0 | 746 } |