Mercurial > sdl-ios-xcode
annotate src/video/wincommon/SDL_sysevents.c @ 1:cf2af46e9e2a
Changes since SDL 1.2.0 release
| author | Sam Lantinga <slouken@lokigames.com> |
|---|---|
| date | Thu, 26 Apr 2001 16:50:19 +0000 |
| parents | 74212992fb08 |
| children | e30a8ce27c22 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
| 3 Copyright (C) 1997, 1998, 1999 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 <stdlib.h> | |
| 29 #include <stdio.h> | |
| 30 #include <windows.h> | |
| 31 | |
| 32 #include "SDL_getenv.h" | |
| 33 #include "SDL_events.h" | |
| 34 #include "SDL_video.h" | |
| 35 #include "SDL_error.h" | |
| 36 #include "SDL_syswm.h" | |
| 37 #include "SDL_sysevents.h" | |
| 38 #include "SDL_events_c.h" | |
| 39 #include "SDL_sysvideo.h" | |
| 40 #include "SDL_lowvideo.h" | |
| 41 #include "SDL_syswm_c.h" | |
| 42 #include "SDL_main.h" | |
| 43 | |
| 44 #ifdef WMMSG_DEBUG | |
| 45 #include "wmmsg.h" | |
| 46 #endif | |
| 47 | |
| 48 #ifdef _WIN32_WCE | |
| 49 #define NO_GETKEYBOARDSTATE | |
| 50 #endif | |
| 51 | |
| 52 /* The window we use for everything... */ | |
| 53 const char *SDL_Appname = NULL; | |
| 54 HINSTANCE SDL_Instance = NULL; | |
| 55 HWND SDL_Window = NULL; | |
| 56 RECT SDL_bounds = {0, 0, 0, 0}; | |
| 57 int SDL_resizing = 0; | |
| 58 int mouse_relative = 0; | |
| 59 int posted = 0; | |
| 60 | |
| 61 | |
| 62 /* Functions called by the message processing function */ | |
| 63 LONG | |
| 64 (*HandleMessage)(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)=NULL; | |
| 65 void (*WIN_RealizePalette)(_THIS); | |
| 66 void (*WIN_PaletteChanged)(_THIS, HWND window); | |
| 67 void (*WIN_SwapGamma)(_THIS); | |
| 68 void (*WIN_WinPAINT)(_THIS, HDC hdc); | |
| 69 | |
| 70 #ifdef WM_MOUSELEAVE | |
| 71 /* | |
| 72 Special code to handle mouse leave events - this sucks... | |
| 73 http://support.microsoft.com/support/kb/articles/q183/1/07.asp | |
| 74 | |
| 75 TrackMouseEvent() is only available on Win98 and WinNT. | |
| 76 _TrackMouseEvent() is available on Win95, but isn't yet in the mingw32 | |
| 77 development environment, and only works on systems that have had IE 3.0 | |
| 78 or newer installed on them (which is not the case with the base Win95). | |
| 79 Therefore, we implement our own version of _TrackMouseEvent() which | |
| 80 uses our own implementation if TrackMouseEvent() is not available. | |
| 81 */ | |
| 82 static BOOL (WINAPI *_TrackMouseEvent)(TRACKMOUSEEVENT *ptme) = NULL; | |
| 83 | |
| 84 static VOID CALLBACK | |
| 85 TrackMouseTimerProc(HWND hWnd, UINT uMsg, UINT idEvent, DWORD dwTime) | |
| 86 { | |
| 87 RECT rect; | |
| 88 POINT pt; | |
| 89 | |
| 90 GetClientRect(hWnd, &rect); | |
| 91 MapWindowPoints(hWnd, NULL, (LPPOINT)&rect, 2); | |
| 92 GetCursorPos(&pt); | |
| 93 if ( !PtInRect(&rect, pt) || (WindowFromPoint(pt) != hWnd) ) { | |
| 94 if ( !KillTimer(hWnd, idEvent) ) { | |
| 95 /* Error killing the timer! */ | |
| 96 } | |
| 97 PostMessage(hWnd, WM_MOUSELEAVE, 0, 0); | |
| 98 } | |
| 99 } | |
| 100 static BOOL WINAPI WIN_TrackMouseEvent(TRACKMOUSEEVENT *ptme) | |
| 101 { | |
| 102 if ( ptme->dwFlags == TME_LEAVE ) { | |
| 103 return SetTimer(ptme->hwndTrack, ptme->dwFlags, 100, | |
| 104 (TIMERPROC)TrackMouseTimerProc); | |
| 105 } | |
| 106 return FALSE; | |
| 107 } | |
| 108 #endif /* WM_MOUSELEAVE */ | |
| 109 | |
| 110 /* Function to retrieve the current keyboard modifiers */ | |
| 111 static void WIN_GetKeyboardState(void) | |
| 112 { | |
| 113 #ifndef NO_GETKEYBOARDSTATE | |
| 114 SDLMod state; | |
| 115 BYTE keyboard[256]; | |
| 116 | |
| 117 state = KMOD_NONE; | |
| 118 if ( GetKeyboardState(keyboard) ) { | |
| 119 if ( keyboard[VK_LSHIFT] & 0x80) { | |
| 120 state |= KMOD_LSHIFT; | |
| 121 } | |
| 122 if ( keyboard[VK_RSHIFT] & 0x80) { | |
| 123 state |= KMOD_RSHIFT; | |
| 124 } | |
| 125 if ( keyboard[VK_LCONTROL] & 0x80) { | |
| 126 state |= KMOD_LCTRL; | |
| 127 } | |
| 128 if ( keyboard[VK_RCONTROL] & 0x80) { | |
| 129 state |= KMOD_RCTRL; | |
| 130 } | |
| 131 if ( keyboard[VK_LMENU] & 0x80) { | |
| 132 state |= KMOD_LALT; | |
| 133 } | |
| 134 if ( keyboard[VK_RMENU] & 0x80) { | |
| 135 state |= KMOD_RALT; | |
| 136 } | |
|
1
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
137 if ( keyboard[VK_NUMLOCK] & 0x01) { |
| 0 | 138 state |= KMOD_NUM; |
| 139 } | |
|
1
cf2af46e9e2a
Changes since SDL 1.2.0 release
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
140 if ( keyboard[VK_CAPITAL] & 0x01) { |
| 0 | 141 state |= KMOD_CAPS; |
| 142 } | |
| 143 } | |
| 144 SDL_SetModState(state); | |
| 145 #endif /* !NO_GETKEYBOARDSTATE */ | |
| 146 } | |
| 147 | |
| 148 /* The main Win32 event handler */ | |
| 149 static LONG CALLBACK WinMessage(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) | |
| 150 { | |
| 151 SDL_VideoDevice *this = current_video; | |
| 152 static int mouse_pressed = 0; | |
| 153 static int in_window = 0; | |
| 154 #ifdef WMMSG_DEBUG | |
| 155 fprintf(stderr, "Received windows message: "); | |
| 156 if ( msg > MAX_WMMSG ) { | |
| 157 fprintf(stderr, "%d", msg); | |
| 158 } else { | |
| 159 fprintf(stderr, "%s", wmtab[msg]); | |
| 160 } | |
| 161 fprintf(stderr, " -- 0x%X, 0x%X\n", wParam, lParam); | |
| 162 #endif | |
| 163 switch (msg) { | |
| 164 | |
| 165 case WM_ACTIVATE: { | |
| 166 SDL_VideoDevice *this = current_video; | |
| 167 BOOL minimized; | |
| 168 Uint8 appstate; | |
| 169 | |
| 170 minimized = HIWORD(wParam); | |
| 171 if ( !minimized && (LOWORD(wParam) != WA_INACTIVE) ) { | |
| 172 /* Gain the following states */ | |
| 173 appstate = SDL_APPACTIVE|SDL_APPINPUTFOCUS; | |
| 174 if ( this->input_grab != SDL_GRAB_OFF ) { | |
| 175 WIN_GrabInput(this, SDL_GRAB_ON); | |
| 176 } | |
| 177 if ( !(SDL_GetAppState()&SDL_APPINPUTFOCUS) ) { | |
| 178 WIN_SwapGamma(this); | |
| 179 } | |
| 180 posted = SDL_PrivateAppActive(1, appstate); | |
| 181 WIN_GetKeyboardState(); | |
| 182 } else { | |
| 183 /* Lose the following states */ | |
| 184 appstate = SDL_APPINPUTFOCUS; | |
| 185 if ( minimized ) { | |
| 186 appstate |= SDL_APPACTIVE; | |
| 187 } | |
| 188 if ( this->input_grab != SDL_GRAB_OFF ) { | |
| 189 WIN_GrabInput(this, SDL_GRAB_OFF); | |
| 190 } | |
| 191 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) { | |
| 192 WIN_SwapGamma(this); | |
| 193 } | |
| 194 posted = SDL_PrivateAppActive(0, appstate); | |
| 195 } | |
| 196 return(0); | |
| 197 } | |
| 198 break; | |
| 199 | |
| 200 case WM_MOUSEMOVE: { | |
| 201 | |
| 202 /* Mouse is handled by DirectInput when fullscreen */ | |
| 203 if ( SDL_VideoSurface && ! DIRECTX_FULLSCREEN() ) { | |
| 204 Sint16 x, y; | |
| 205 | |
| 206 /* mouse has entered the window */ | |
| 207 if ( ! in_window ) { | |
| 208 #ifdef WM_MOUSELEAVE | |
| 209 TRACKMOUSEEVENT tme; | |
| 210 | |
| 211 tme.cbSize = sizeof(tme); | |
| 212 tme.dwFlags = TME_LEAVE; | |
| 213 tme.hwndTrack = SDL_Window; | |
| 214 _TrackMouseEvent(&tme); | |
| 215 #endif /* WM_MOUSELEAVE */ | |
| 216 in_window = TRUE; | |
| 217 | |
| 218 posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); | |
| 219 } | |
| 220 | |
| 221 /* mouse has moved within the window */ | |
| 222 x = LOWORD(lParam); | |
| 223 y = HIWORD(lParam); | |
| 224 if ( mouse_relative ) { | |
| 225 POINT center; | |
| 226 center.x = (SDL_VideoSurface->w/2); | |
| 227 center.y = (SDL_VideoSurface->h/2); | |
| 228 x -= (Sint16)center.x; | |
| 229 y -= (Sint16)center.y; | |
| 230 if ( x || y ) { | |
| 231 ClientToScreen(SDL_Window, ¢er); | |
| 232 SetCursorPos(center.x, center.y); | |
| 233 posted = SDL_PrivateMouseMotion(0, 1, x, y); | |
| 234 } | |
| 235 } else { | |
| 236 posted = SDL_PrivateMouseMotion(0, 0, x, y); | |
| 237 } | |
| 238 } | |
| 239 } | |
| 240 return(0); | |
| 241 | |
| 242 #ifdef WM_MOUSELEAVE | |
| 243 case WM_MOUSELEAVE: { | |
| 244 | |
| 245 /* Mouse is handled by DirectInput when fullscreen */ | |
| 246 if ( SDL_VideoSurface && ! DIRECTX_FULLSCREEN() ) { | |
| 247 /* mouse has left the window */ | |
| 248 /* or */ | |
| 249 /* Elvis has left the building! */ | |
| 250 in_window = FALSE; | |
| 251 posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); | |
| 252 } | |
| 253 } | |
| 254 return(0); | |
| 255 #endif /* WM_MOUSELEAVE */ | |
| 256 | |
| 257 case WM_LBUTTONDOWN: | |
| 258 case WM_LBUTTONUP: | |
| 259 case WM_MBUTTONDOWN: | |
| 260 case WM_MBUTTONUP: | |
| 261 case WM_RBUTTONDOWN: | |
| 262 case WM_RBUTTONUP: { | |
| 263 /* Mouse is handled by DirectInput when fullscreen */ | |
| 264 if ( SDL_VideoSurface && ! DIRECTX_FULLSCREEN() ) { | |
| 265 Sint16 x, y; | |
| 266 Uint8 button, state; | |
| 267 | |
| 268 /* Figure out which button to use */ | |
| 269 switch (msg) { | |
| 270 case WM_LBUTTONDOWN: | |
| 271 button = 1; | |
| 272 state = SDL_PRESSED; | |
| 273 break; | |
| 274 case WM_LBUTTONUP: | |
| 275 button = 1; | |
| 276 state = SDL_RELEASED; | |
| 277 break; | |
| 278 case WM_MBUTTONDOWN: | |
| 279 button = 2; | |
| 280 state = SDL_PRESSED; | |
| 281 break; | |
| 282 case WM_MBUTTONUP: | |
| 283 button = 2; | |
| 284 state = SDL_RELEASED; | |
| 285 break; | |
| 286 case WM_RBUTTONDOWN: | |
| 287 button = 3; | |
| 288 state = SDL_PRESSED; | |
| 289 break; | |
| 290 case WM_RBUTTONUP: | |
| 291 button = 3; | |
| 292 state = SDL_RELEASED; | |
| 293 break; | |
| 294 default: | |
| 295 /* Eh? Unknown button? */ | |
| 296 return(0); | |
| 297 } | |
| 298 if ( state == SDL_PRESSED ) { | |
| 299 /* Grab mouse so we get up events */ | |
| 300 if ( ++mouse_pressed > 0 ) { | |
| 301 SetCapture(hwnd); | |
| 302 } | |
| 303 } else { | |
| 304 /* Release mouse after all up events */ | |
| 305 if ( --mouse_pressed <= 0 ) { | |
| 306 ReleaseCapture(); | |
| 307 mouse_pressed = 0; | |
| 308 } | |
| 309 } | |
| 310 if ( mouse_relative ) { | |
| 311 /* RJR: March 28, 2000 | |
| 312 report internal mouse position if in relative mode */ | |
| 313 x = 0; y = 0; | |
| 314 } else { | |
| 315 x = (Sint16)LOWORD(lParam); | |
| 316 y = (Sint16)HIWORD(lParam); | |
| 317 } | |
| 318 posted = SDL_PrivateMouseButton( | |
| 319 state, button, x, y); | |
| 320 } | |
| 321 } | |
| 322 return(0); | |
| 323 | |
| 324 #ifdef WM_GETMINMAXINFO | |
| 325 /* This message is sent as a way for us to "check" the values | |
| 326 * of a position change. If we don't like it, we can adjust | |
| 327 * the values before they are changed. | |
| 328 */ | |
| 329 case WM_GETMINMAXINFO: { | |
| 330 MINMAXINFO *info; | |
| 331 RECT size; | |
| 332 int x, y; | |
| 333 int width; | |
| 334 int height; | |
| 335 | |
| 336 /* We don't want to clobber an internal resize */ | |
| 337 if ( SDL_resizing ) | |
| 338 return(0); | |
| 339 | |
| 340 /* We allow resizing with the SDL_RESIZABLE flag */ | |
| 341 if ( SDL_PublicSurface && | |
| 342 (SDL_PublicSurface->flags & SDL_RESIZABLE) ) { | |
| 343 return(0); | |
| 344 } | |
| 345 | |
| 346 /* Get the current position of our window */ | |
| 347 GetWindowRect(SDL_Window, &size); | |
| 348 x = size.left; | |
| 349 y = size.top; | |
| 350 | |
| 351 /* Calculate current width and height of our window */ | |
| 352 size.top = 0; | |
| 353 size.left = 0; | |
| 354 if ( SDL_PublicSurface != NULL ) { | |
| 355 size.bottom = SDL_PublicSurface->h; | |
| 356 size.right = SDL_PublicSurface->w; | |
| 357 } else { | |
| 358 size.bottom = 0; | |
| 359 size.right = 0; | |
| 360 } | |
| 361 AdjustWindowRect(&size, GetWindowLong(hwnd, GWL_STYLE), | |
| 362 FALSE); | |
| 363 width = size.right - size.left; | |
| 364 height = size.bottom - size.top; | |
| 365 | |
| 366 /* Fix our size to the current size */ | |
| 367 info = (MINMAXINFO *)lParam; | |
| 368 info->ptMaxSize.x = width; | |
| 369 info->ptMaxSize.y = height; | |
| 370 info->ptMaxPosition.x = x; | |
| 371 info->ptMaxPosition.y = y; | |
| 372 info->ptMinTrackSize.x = width; | |
| 373 info->ptMinTrackSize.y = height; | |
| 374 info->ptMaxTrackSize.x = width; | |
| 375 info->ptMaxTrackSize.y = height; | |
| 376 } | |
| 377 return(0); | |
| 378 #endif /* WM_GETMINMAXINFO */ | |
| 379 | |
| 380 case WM_MOVE: { | |
| 381 SDL_VideoDevice *this = current_video; | |
| 382 | |
| 383 GetClientRect(SDL_Window, &SDL_bounds); | |
| 384 ClientToScreen(SDL_Window, (LPPOINT)&SDL_bounds); | |
| 385 ClientToScreen(SDL_Window, (LPPOINT)&SDL_bounds+1); | |
| 386 if ( this->input_grab != SDL_GRAB_OFF ) { | |
| 387 ClipCursor(&SDL_bounds); | |
| 388 } | |
| 389 } | |
| 390 break; | |
| 391 | |
| 392 case WM_SIZE: { | |
| 393 if ( SDL_PublicSurface && | |
| 394 (SDL_PublicSurface->flags & SDL_RESIZABLE) ) { | |
| 395 SDL_PrivateResize(LOWORD(lParam), HIWORD(lParam)); | |
| 396 } | |
| 397 return(0); | |
| 398 } | |
| 399 break; | |
| 400 | |
| 401 /* We need to set the cursor */ | |
| 402 case WM_SETCURSOR: { | |
| 403 Uint16 hittest; | |
| 404 | |
| 405 hittest = LOWORD(lParam); | |
| 406 if ( hittest == HTCLIENT ) { | |
| 407 SetCursor(SDL_hcursor); | |
| 408 return(TRUE); | |
| 409 } | |
| 410 } | |
| 411 break; | |
| 412 | |
| 413 /* We are about to get palette focus! */ | |
| 414 case WM_QUERYNEWPALETTE: { | |
| 415 WIN_RealizePalette(current_video); | |
| 416 return(TRUE); | |
| 417 } | |
| 418 break; | |
| 419 | |
| 420 /* Another application changed the palette */ | |
| 421 case WM_PALETTECHANGED: { | |
| 422 WIN_PaletteChanged(current_video, (HWND)wParam); | |
| 423 } | |
| 424 break; | |
| 425 | |
| 426 /* We were occluded, refresh our display */ | |
| 427 case WM_PAINT: { | |
| 428 HDC hdc; | |
| 429 PAINTSTRUCT ps; | |
| 430 | |
| 431 hdc = BeginPaint(SDL_Window, &ps); | |
| 432 if ( current_video->screen && | |
| 433 !(current_video->screen->flags & SDL_OPENGL) ) { | |
| 434 WIN_WinPAINT(current_video, hdc); | |
| 435 } | |
| 436 EndPaint(SDL_Window, &ps); | |
| 437 } | |
| 438 return(0); | |
| 439 | |
| 440 case WM_ERASEBKGND: { | |
| 441 /* Just do nothing */ ; | |
| 442 } | |
| 443 return(1); | |
| 444 | |
| 445 case WM_CLOSE: { | |
| 446 if ( (posted = SDL_PrivateQuit()) ) | |
| 447 PostQuitMessage(0); | |
| 448 } | |
| 449 return(0); | |
| 450 | |
| 451 case WM_DESTROY: { | |
| 452 PostQuitMessage(0); | |
| 453 } | |
| 454 return(0); | |
| 455 | |
| 456 default: { | |
| 457 /* Special handling by the video driver */ | |
| 458 if (HandleMessage) { | |
| 459 return(HandleMessage(current_video, | |
| 460 hwnd, msg, wParam, lParam)); | |
| 461 } | |
| 462 } | |
| 463 break; | |
| 464 } | |
| 465 return(DefWindowProc(hwnd, msg, wParam, lParam)); | |
| 466 } | |
| 467 | |
| 468 /* This allows the SDL_WINDOWID hack */ | |
| 469 const char *SDL_windowid = NULL; | |
| 470 | |
| 471 /* Register the class for this application -- exported for winmain.c */ | |
| 472 int SDL_RegisterApp(char *name, Uint32 style, void *hInst) | |
| 473 { | |
| 474 static int initialized = 0; | |
| 475 WNDCLASS class; | |
| 476 #ifdef WM_MOUSELEAVE | |
| 477 HMODULE handle; | |
| 478 #endif | |
| 479 | |
| 480 /* Only do this once... */ | |
| 481 if ( initialized ) { | |
| 482 return(0); | |
| 483 } | |
| 484 | |
| 485 /* This function needs to be passed the correct process handle | |
| 486 by the application. The following call just returns a handle | |
| 487 to the SDL DLL, which is useless for our purposes and causes | |
| 488 DirectInput to fail to initialize. | |
| 489 */ | |
| 490 if ( ! hInst ) { | |
| 491 hInst = GetModuleHandle(NULL); | |
| 492 } | |
| 493 | |
| 494 /* Register the application class */ | |
| 495 class.hCursor = NULL; | |
| 496 #ifdef _WIN32_WCE | |
| 497 { | |
| 498 /* WinCE uses the UNICODE version */ | |
| 499 int nLen = strlen(name); | |
| 500 LPWSTR lpszW = alloca((nLen+1)*2); | |
| 501 MultiByteToWideChar(CP_ACP, 0, name, -1, lpszW, nLen); | |
| 502 class.hIcon = LoadImage(hInst, lpszW, IMAGE_ICON, | |
| 503 0, 0, LR_DEFAULTCOLOR); | |
| 504 class.lpszMenuName = lpszW; | |
| 505 class.lpszClassName = lpszW; | |
| 506 } | |
| 507 #else | |
| 508 class.hIcon = LoadImage(hInst, name, IMAGE_ICON, | |
| 509 0, 0, LR_DEFAULTCOLOR); | |
| 510 class.lpszMenuName = "(none)"; | |
| 511 class.lpszClassName = name; | |
| 512 #endif /* _WIN32_WCE */ | |
| 513 class.hbrBackground = NULL; | |
| 514 class.hInstance = hInst ? hInst : GetModuleHandle(0); | |
| 515 class.style = style; | |
| 516 #ifdef HAVE_OPENGL | |
| 517 class.style |= CS_OWNDC; | |
| 518 #endif | |
| 519 class.lpfnWndProc = WinMessage; | |
| 520 class.cbWndExtra = 0; | |
| 521 class.cbClsExtra = 0; | |
| 522 if ( ! RegisterClass(&class) ) { | |
| 523 SDL_SetError("Couldn't register application class"); | |
| 524 return(-1); | |
| 525 } | |
| 526 SDL_Appname = name; | |
| 527 SDL_Instance = hInst; | |
| 528 | |
| 529 #ifdef WM_MOUSELEAVE | |
| 530 /* Get the version of TrackMouseEvent() we use */ | |
| 531 _TrackMouseEvent = NULL; | |
| 532 handle = GetModuleHandle("USER32.DLL"); | |
| 533 if ( handle ) { | |
| 534 _TrackMouseEvent = (BOOL (WINAPI *)(TRACKMOUSEEVENT *))GetProcAddress(handle, "TrackMouseEvent"); | |
| 535 } | |
| 536 if ( _TrackMouseEvent == NULL ) { | |
| 537 _TrackMouseEvent = WIN_TrackMouseEvent; | |
| 538 } | |
| 539 #endif /* WM_MOUSELEAVE */ | |
| 540 | |
| 541 /* Check for SDL_WINDOWID hack */ | |
| 542 SDL_windowid = getenv("SDL_WINDOWID"); | |
| 543 | |
| 544 initialized = 1; | |
| 545 return(0); | |
| 546 } | |
| 547 |