Mercurial > sdl-ios-xcode
annotate src/video/windx5/SDL_dx5events.c @ 4427:eada7e321df6 SDL-1.2
Fixed bug #943
Ozkan Sezer 2010-02-06 12:31:06 PST
Hi:
Here are some small fixes for compiling SDL against mingw-w64.
(see http://mingw-w64.sourceforge.net/ . Despite the name, it
supports both win32 and win64.) Two patches, one for SDL-1.2
and one for SDL-1.3 attached.
src/audio/windx5/directx.h and src/video/windx5/directx.h (both
SDL-1.2 and SDL-1.3.) I get compilation errors about some union
not having a member named u1 and alike, because of other system
headers being included before this one and them already defining
DUMMYUNIONNAME and stuff. This header probably assumes that those
stuff are defined in windef.h, but mingw-w64 headers define them
in _mingw.h. Easily fixed by moving NONAMELESSUNION definition to
the top of the file. SDL_dx5yuv.c (SDL-1.2-only) also needs to
include the header before SDL_video.h to avoid the same problem.
src/thread/win32/SDL_systhread.c (both SDL-1.2 and SDL-1.3.) :
The __GNUC__ case for pfnSDL_CurrentBeginThread is 32-bit centric
because _beginthreadex returns uintptr_t, not unsigned long which
is 32 bits in win64. Changing the return type to uintptr_t fixes
it.
Hope these are useful. Thanks.
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Wed, 10 Mar 2010 15:04:13 +0000 |
| parents | 9afe12fb4c41 |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 2 SDL - Simple DirectMedia Layer | |
| 4159 | 3 Copyright (C) 1997-2009 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:
1303
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:
1303
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:
1303
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:
1303
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:
1303
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:
1303
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:
145
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 /* CAUTION!!!! If you modify this file, check ../windib/SDL_sysevents.c */ | |
| 25 | |
| 26 #include "directx.h" | |
| 27 | |
|
1358
c71e05b4dc2e
More header massaging... works great on Windows. ;-)
Sam Lantinga <slouken@libsdl.org>
parents:
1348
diff
changeset
|
28 #include "SDL_main.h" |
| 0 | 29 #include "SDL_events.h" |
| 30 #include "SDL_video.h" | |
| 31 #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
|
32 #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
|
33 #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
|
34 #include "../wincommon/SDL_lowvideo.h" |
| 0 | 35 #include "SDL_dx5video.h" |
| 36 | |
| 37 #ifndef WM_APP | |
| 38 #define WM_APP 0x8000 | |
| 39 #endif | |
| 40 | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
41 #ifdef _WIN32_WCE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
42 #define NO_GETKEYBOARDSTATE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
43 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
44 |
| 0 | 45 /* The keyboard and mouse device input */ |
|
4237
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
46 #define MAX_INPUTS 2 |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
47 #define INPUT_QSIZE 512 /* Buffer up to 512 input messages */ |
| 0 | 48 |
| 49 static LPDIRECTINPUT dinput = NULL; | |
| 50 static LPDIRECTINPUTDEVICE2 SDL_DIdev[MAX_INPUTS]; | |
| 51 static HANDLE SDL_DIevt[MAX_INPUTS]; | |
| 52 static void (*SDL_DIfun[MAX_INPUTS])(const int, DIDEVICEOBJECTDATA *); | |
| 53 static int SDL_DIndev = 0; | |
| 54 static int mouse_lost; | |
| 55 static int mouse_pressed; | |
|
491
da6a7e859616
Applied John Popplewell's fix for left-handed mice under Windows.
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
56 static int mouse_buttons_swapped = 0; |
| 0 | 57 |
| 58 /* The translation table from a DirectInput scancode to an SDL keysym */ | |
| 59 static SDLKey DIK_keymap[256]; | |
| 60 static SDL_keysym *TranslateKey(UINT scancode, SDL_keysym *keysym, int pressed); | |
| 61 | |
|
145
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
61
diff
changeset
|
62 /* DJM: If the user setup the window for us, we want to save his window proc, |
|
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
61
diff
changeset
|
63 and give him a chance to handle some messages. */ |
|
1303
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
64 #ifdef STRICT |
|
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
65 #define WNDPROCTYPE WNDPROC |
|
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
66 #else |
|
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
67 #define WNDPROCTYPE FARPROC |
|
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
68 #endif |
|
52b5afd7ecee
Date: Tue, 05 Jul 2005 21:43:26 +1000
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
69 static WNDPROCTYPE userWindowProc = NULL; |
|
145
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
61
diff
changeset
|
70 |
|
1114
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
71 static HWND GetTopLevelParent(HWND hWnd) |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
72 { |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
73 HWND hParentWnd; |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
74 while (1) |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
75 { |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
76 hParentWnd = GetParent(hWnd); |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
77 if (hParentWnd == NULL) |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
78 break; |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
79 hWnd = hParentWnd; |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
80 } |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
81 return hWnd; |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
82 } |
|
242a35a85852
Patches to make SDL compatible with Win95 again.
Ryan C. Gordon <icculus@icculus.org>
parents:
975
diff
changeset
|
83 |
| 0 | 84 /* Convert a DirectInput return code to a text message */ |
| 85 static void SetDIerror(char *function, int code) | |
| 86 { | |
| 87 static char *error; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
88 static char errbuf[1024]; |
| 0 | 89 |
| 90 errbuf[0] = 0; | |
| 91 switch (code) { | |
| 92 case DIERR_GENERIC: | |
| 93 error = "Undefined error!"; | |
| 94 break; | |
| 95 case DIERR_OLDDIRECTINPUTVERSION: | |
| 96 error = "Your version of DirectInput needs upgrading"; | |
| 97 break; | |
| 98 case DIERR_INVALIDPARAM: | |
| 99 error = "Invalid parameters"; | |
| 100 break; | |
| 101 case DIERR_OUTOFMEMORY: | |
| 102 error = "Out of memory"; | |
| 103 break; | |
| 104 case DIERR_DEVICENOTREG: | |
| 105 error = "Device not registered"; | |
| 106 break; | |
| 107 case DIERR_NOINTERFACE: | |
| 108 error = "Interface not supported"; | |
| 109 break; | |
| 110 case DIERR_NOTINITIALIZED: | |
| 111 error = "Device not initialized"; | |
| 112 break; | |
| 113 default: | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
114 SDL_snprintf(errbuf, SDL_arraysize(errbuf), |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
115 "%s: Unknown DirectInput error: 0x%x", |
| 0 | 116 function, code); |
| 117 break; | |
| 118 } | |
| 119 if ( ! errbuf[0] ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
120 SDL_snprintf(errbuf, SDL_arraysize(errbuf), "%s: %s", function, error); |
| 0 | 121 } |
| 122 SDL_SetError("%s", errbuf); | |
| 123 return; | |
| 124 } | |
| 125 | |
| 126 /* Initialize DirectInput | |
| 127 Note: If NONEXCLUSIVE access is requested for the devices, normal | |
| 128 windows input messages will continue to be generated for that | |
| 129 input device, in addition to DirectInput messages. | |
| 130 */ | |
| 131 static void handle_keyboard(const int numevents, DIDEVICEOBJECTDATA *events); | |
| 132 static void handle_mouse(const int numevents, DIDEVICEOBJECTDATA *events); | |
| 133 struct { | |
| 134 char *name; | |
| 135 REFGUID guid; | |
| 136 LPCDIDATAFORMAT format; | |
| 137 DWORD win_level; | |
| 138 DWORD raw_level; | |
| 139 void (*fun)(const int numevents, DIDEVICEOBJECTDATA *events); | |
| 140 } inputs[] = { | |
| 141 { "keyboard", | |
| 142 &GUID_SysKeyboard, &c_dfDIKeyboard, | |
| 143 (DISCL_FOREGROUND|DISCL_NONEXCLUSIVE), | |
| 144 (DISCL_FOREGROUND|DISCL_NONEXCLUSIVE), handle_keyboard }, | |
| 145 { "mouse", | |
| 4167 | 146 &GUID_SysMouse, |
| 147 #if DIRECTINPUT_VERSION >= 0x700 | |
| 148 &c_dfDIMouse2, | |
| 149 #else | |
| 150 &c_dfDIMouse, | |
| 151 #endif | |
|
4391
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
152 (DISCL_BACKGROUND|DISCL_NONEXCLUSIVE), |
|
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
153 (DISCL_BACKGROUND|DISCL_NONEXCLUSIVE), handle_mouse }, |
| 0 | 154 { NULL, NULL, NULL, 0, 0, NULL } |
| 155 }; | |
| 156 | |
| 157 static int DX5_DInputInit(_THIS) | |
| 158 { | |
| 159 int i; | |
| 160 LPDIRECTINPUTDEVICE device; | |
| 161 HRESULT result; | |
| 162 DIPROPDWORD dipdw; | |
|
970
fb8b91365766
Date: Tue, 19 Oct 2004 23:04:58 -0700
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
163 HWND topwnd; |
| 0 | 164 |
| 165 /* Create the DirectInput object */ | |
| 166 result = DInputCreate(SDL_Instance, DIRECTINPUT_VERSION, | |
| 167 &dinput, NULL); | |
| 168 if ( result != DI_OK ) { | |
| 169 SetDIerror("DirectInputCreate", result); | |
| 170 return(-1); | |
| 171 } | |
| 172 | |
| 173 /* Create all of our registered input devices */ | |
| 174 SDL_DIndev = 0; | |
| 175 for ( i=0; inputs[i].name; ++i ) { | |
| 176 /* Create the DirectInput device */ | |
| 177 result = IDirectInput_CreateDevice(dinput, inputs[i].guid, | |
| 178 &device, NULL); | |
| 179 if ( result != DI_OK ) { | |
| 180 SetDIerror("DirectInput::CreateDevice", result); | |
| 181 return(-1); | |
| 182 } | |
| 183 result = IDirectInputDevice_QueryInterface(device, | |
| 184 &IID_IDirectInputDevice2, (LPVOID *)&SDL_DIdev[i]); | |
| 185 IDirectInputDevice_Release(device); | |
| 186 if ( result != DI_OK ) { | |
| 187 SetDIerror("DirectInputDevice::QueryInterface", result); | |
| 188 return(-1); | |
| 189 } | |
|
1115
040aa1bea9fc
Fixed mismerged patch.
Ryan C. Gordon <icculus@icculus.org>
parents:
1114
diff
changeset
|
190 topwnd = GetTopLevelParent(SDL_Window); |
| 0 | 191 result = IDirectInputDevice2_SetCooperativeLevel(SDL_DIdev[i], |
|
970
fb8b91365766
Date: Tue, 19 Oct 2004 23:04:58 -0700
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
192 topwnd, inputs[i].win_level); |
| 0 | 193 if ( result != DI_OK ) { |
| 194 SetDIerror("DirectInputDevice::SetCooperativeLevel", | |
| 195 result); | |
| 196 return(-1); | |
| 197 } | |
| 198 result = IDirectInputDevice2_SetDataFormat(SDL_DIdev[i], | |
| 199 inputs[i].format); | |
| 200 if ( result != DI_OK ) { | |
| 201 SetDIerror("DirectInputDevice::SetDataFormat", result); | |
| 202 return(-1); | |
| 203 } | |
| 204 | |
| 205 /* Set buffered input -- we aren't polling */ | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
206 SDL_memset(&dipdw, 0, sizeof(dipdw)); |
| 0 | 207 dipdw.diph.dwSize = sizeof(dipdw); |
| 208 dipdw.diph.dwHeaderSize = sizeof(dipdw.diph); | |
| 209 dipdw.diph.dwObj = 0; | |
| 210 dipdw.diph.dwHow = DIPH_DEVICE; | |
| 211 dipdw.dwData = INPUT_QSIZE; | |
| 212 result = IDirectInputDevice2_SetProperty(SDL_DIdev[i], | |
| 213 DIPROP_BUFFERSIZE, &dipdw.diph); | |
| 214 if ( result != DI_OK ) { | |
| 215 SetDIerror("DirectInputDevice::SetProperty", result); | |
| 216 return(-1); | |
| 217 } | |
| 218 | |
| 219 /* Create an event to be signaled when input is ready */ | |
| 220 SDL_DIevt[i] = CreateEvent(NULL, FALSE, FALSE, NULL); | |
| 221 if ( SDL_DIevt[i] == NULL ) { | |
| 222 SDL_SetError("Couldn't create DirectInput event"); | |
| 223 return(-1); | |
| 224 } | |
| 225 result = IDirectInputDevice2_SetEventNotification(SDL_DIdev[i], | |
| 226 SDL_DIevt[i]); | |
| 227 if ( result != DI_OK ) { | |
| 228 SetDIerror("DirectInputDevice::SetEventNotification", | |
| 229 result); | |
| 230 return(-1); | |
| 231 } | |
| 232 SDL_DIfun[i] = inputs[i].fun; | |
| 233 | |
| 234 /* Acquire the device for input */ | |
| 235 IDirectInputDevice2_Acquire(SDL_DIdev[i]); | |
| 236 | |
| 237 /* Increment the number of devices we have */ | |
| 238 ++SDL_DIndev; | |
| 239 } | |
| 240 mouse_pressed = 0; | |
|
491
da6a7e859616
Applied John Popplewell's fix for left-handed mice under Windows.
Sam Lantinga <slouken@libsdl.org>
parents:
460
diff
changeset
|
241 mouse_buttons_swapped = GetSystemMetrics(SM_SWAPBUTTON); |
| 0 | 242 |
| 243 /* DirectInput is ready! */ | |
| 244 return(0); | |
| 245 } | |
| 246 | |
| 247 /* Clean up DirectInput */ | |
| 248 static void DX5_DInputQuit(_THIS) | |
| 249 { | |
| 250 int i; | |
| 251 | |
| 252 if ( dinput != NULL ) { | |
| 253 /* Close and release all DirectInput devices */ | |
| 254 for ( i=0; i<MAX_INPUTS; ++i ) { | |
| 255 if ( SDL_DIdev[i] != NULL ) { | |
| 256 IDirectInputDevice2_Unacquire(SDL_DIdev[i]); | |
| 257 IDirectInputDevice2_SetEventNotification( | |
| 258 SDL_DIdev[i], NULL); | |
| 259 if ( SDL_DIevt[i] != NULL ) { | |
| 260 CloseHandle(SDL_DIevt[i]); | |
| 261 SDL_DIevt[i] = NULL; | |
| 262 } | |
| 263 IDirectInputDevice2_Release(SDL_DIdev[i]); | |
| 264 SDL_DIdev[i] = NULL; | |
| 265 } | |
| 266 } | |
|
4237
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
267 SDL_DIndev = 0; |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
268 |
| 0 | 269 /* Release DirectInput */ |
| 270 IDirectInput_Release(dinput); | |
| 271 dinput = NULL; | |
| 272 } | |
| 273 } | |
| 274 | |
| 275 /* Flag to tell SDL whether or not we queued an event */ | |
| 276 static int posted = 0; | |
| 277 | |
| 278 /* Input event handler functions */ | |
| 279 static void handle_keyboard(const int numevents, DIDEVICEOBJECTDATA *keybuf) | |
| 280 { | |
| 281 int i; | |
| 282 SDL_keysym keysym; | |
| 283 | |
| 284 /* Translate keyboard messages */ | |
| 285 for ( i=0; i<numevents; ++i ) { | |
| 286 if ( keybuf[i].dwData & 0x80 ) { | |
| 287 posted = SDL_PrivateKeyboard(SDL_PRESSED, | |
| 288 TranslateKey(keybuf[i].dwOfs, &keysym, 1)); | |
| 289 } else { | |
| 290 posted = SDL_PrivateKeyboard(SDL_RELEASED, | |
| 291 TranslateKey(keybuf[i].dwOfs, &keysym, 0)); | |
| 292 } | |
| 293 } | |
| 294 } | |
| 4167 | 295 |
| 296 static void post_mouse_motion(int relative, Sint16 x, Sint16 y) | |
| 297 { | |
| 298 extern int mouse_relative; | |
| 299 | |
|
4391
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
300 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) { |
| 4167 | 301 posted = SDL_PrivateMouseMotion( |
| 302 0, relative, x, y); | |
| 303 | |
| 304 if ( !mouse_relative ) { | |
| 305 /* As DirectInput reads raw device coordinates, it has no notion of | |
| 306 * cursors or absolute position. We must assume responsibility for | |
| 307 * keeping track of this. */ | |
| 308 int current_x, current_y; | |
| 309 POINT cursor; | |
| 310 RECT trap; | |
| 311 RECT window; | |
| 312 int at_edge; | |
| 313 | |
| 314 /* Get the current cursor position */ | |
| 315 SDL_GetMouseState(¤t_x, ¤t_y); | |
| 316 cursor.x = current_x; | |
| 317 cursor.y = current_y; | |
| 318 ClientToScreen(SDL_Window, &cursor); | |
| 319 | |
| 320 /* Construct a 1 pixel square RECT that is used to confine the cursor | |
| 321 * pointer to a specific pixel using ClipCursor. This is used in | |
| 322 * preference to SetCursorPos as it avoids the cursor jumping around as | |
| 323 * both the OS and SDL attempt to move it simultaneously. */ | |
| 324 trap.left = cursor.x; | |
| 325 trap.top = cursor.y; | |
| 326 trap.right = cursor.x + 1; | |
| 327 trap.bottom = cursor.y + 1; | |
| 328 | |
| 329 GetClientRect(SDL_Window, &window); | |
| 330 window.right -= window.left; window.left = 0; | |
| 331 window.bottom -= window.top; window.top = 0; | |
| 332 | |
| 333 /* As we're assuming control over the cursor, we need to know when to | |
| 334 * relinquish control of it back to the operating system. This is when | |
| 335 * the cursor reaches the edge of the window. */ | |
| 336 at_edge = (current_x == window.left) || | |
| 337 (current_x == (window.right - 1)) || | |
| 338 (current_y == window.top) || | |
| 339 (current_y == (window.bottom - 1)); | |
| 340 | |
| 341 if ( at_edge ) { | |
| 342 ClipCursor(NULL); | |
| 343 } else { | |
| 344 ClipCursor(&trap); | |
| 345 } | |
| 346 } else { | |
| 347 /* When in relative mode, warp the OS's idea of where the cursor is to | |
| 348 * the center of the screen. This isn't really necessary as DirectInput | |
| 349 * reads from the hardware itself, but in case things go wrong, the | |
| 350 * cursor will be left in a sensible place. */ | |
| 351 POINT center; | |
| 352 center.x = (SDL_VideoSurface->w/2); | |
| 353 center.y = (SDL_VideoSurface->h/2); | |
| 354 ClientToScreen(SDL_Window, ¢er); | |
| 355 SetCursorPos(center.x, center.y); | |
| 356 } | |
| 357 } | |
| 358 } | |
| 359 | |
| 0 | 360 static void handle_mouse(const int numevents, DIDEVICEOBJECTDATA *ptrbuf) |
| 361 { | |
| 362 int i; | |
| 363 Sint16 xrel, yrel; | |
| 364 Uint8 state; | |
| 365 Uint8 button; | |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
366 DWORD timestamp = 0; |
| 0 | 367 |
|
717
42ed44b2c8b6
Date: Sun, 14 Sep 2003 17:04:55 -0400
Ryan C. Gordon <icculus@icculus.org>
parents:
536
diff
changeset
|
368 /* Sanity check. Mailing list reports this being NULL unexpectedly. */ |
|
42ed44b2c8b6
Date: Sun, 14 Sep 2003 17:04:55 -0400
Ryan C. Gordon <icculus@icculus.org>
parents:
536
diff
changeset
|
369 if (SDL_PublicSurface == NULL) { |
|
42ed44b2c8b6
Date: Sun, 14 Sep 2003 17:04:55 -0400
Ryan C. Gordon <icculus@icculus.org>
parents:
536
diff
changeset
|
370 return; |
|
42ed44b2c8b6
Date: Sun, 14 Sep 2003 17:04:55 -0400
Ryan C. Gordon <icculus@icculus.org>
parents:
536
diff
changeset
|
371 } |
|
42ed44b2c8b6
Date: Sun, 14 Sep 2003 17:04:55 -0400
Ryan C. Gordon <icculus@icculus.org>
parents:
536
diff
changeset
|
372 |
|
4391
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
373 /* If mouse focus has been lost, make sure we release the cursor. */ |
|
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
374 if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) { |
|
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
375 mouse_lost = 1; |
|
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
376 ClipCursor(NULL); |
| 4393 | 377 } else { |
| 378 /* If the mouse was lost, regain some sense of mouse state */ | |
| 379 if ( mouse_lost ) { | |
| 380 POINT mouse_pos; | |
| 381 Uint8 old_state; | |
| 382 Uint8 new_state; | |
|
4391
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
383 |
| 4393 | 384 /* Set ourselves up with the current cursor position */ |
| 385 GetCursorPos(&mouse_pos); | |
| 386 ScreenToClient(SDL_Window, &mouse_pos); | |
| 387 post_mouse_motion( 0, (Sint16)mouse_pos.x, (Sint16)mouse_pos.y); | |
| 0 | 388 |
| 4393 | 389 /* Check for mouse button changes */ |
| 390 old_state = SDL_GetMouseState(NULL, NULL); | |
| 391 new_state = 0; | |
| 392 { /* Get the new DirectInput button state for the mouse */ | |
| 393 #if DIRECTINPUT_VERSION >= 0x700 | |
| 394 DIMOUSESTATE2 distate; | |
| 395 #else | |
| 396 DIMOUSESTATE distate; | |
| 397 #endif | |
| 398 HRESULT result; | |
| 0 | 399 |
| 4393 | 400 result=IDirectInputDevice2_GetDeviceState(SDL_DIdev[1], |
| 401 sizeof(distate), &distate); | |
| 402 if ( result != DI_OK ) { | |
| 403 /* Try again next time */ | |
| 404 SetDIerror( | |
| 405 "IDirectInputDevice2::GetDeviceState", result); | |
| 406 return; | |
| 407 } | |
| 408 for ( i=3; i>=0; --i ) { | |
| 409 if ( (distate.rgbButtons[i]&0x80) == 0x80 ) { | |
| 410 new_state |= 0x01; | |
| 411 } | |
| 412 new_state <<= 1; | |
| 413 } | |
| 0 | 414 } |
| 4393 | 415 for ( i=0; i<8; ++i ) { |
| 416 if ( (old_state&0x01) != (new_state&0x01) ) { | |
| 417 button = (Uint8)(i+1); | |
| 418 /* Map DI button numbers to SDL */ | |
| 419 switch ( button ) { | |
| 420 case 2: button = SDL_BUTTON_RIGHT; break; | |
| 421 case 3: button = SDL_BUTTON_MIDDLE; break; | |
| 422 case 4: button = SDL_BUTTON_X1; break; | |
| 423 case 5: button = SDL_BUTTON_X2; break; | |
| 424 default: break; | |
| 425 } | |
| 426 if ( new_state & 0x01 ) { | |
| 427 /* Grab mouse so we get mouse-up */ | |
| 428 if ( ++mouse_pressed > 0 ) { | |
| 429 SetCapture(SDL_Window); | |
| 430 } | |
| 431 state = SDL_PRESSED; | |
| 432 } else { | |
| 433 /* Release mouse after all mouse-ups */ | |
| 434 if ( --mouse_pressed <= 0 ) { | |
| 435 ReleaseCapture(); | |
| 436 mouse_pressed = 0; | |
| 437 } | |
| 438 state = SDL_RELEASED; | |
| 439 } | |
| 440 if ( mouse_buttons_swapped ) { | |
| 441 if ( button == 1 ) button = 3; | |
| 442 else | |
| 443 if ( button == 3 ) button = 1; | |
| 444 } | |
| 445 posted = SDL_PrivateMouseButton(state, button, | |
| 446 0, 0); | |
| 0 | 447 } |
| 4393 | 448 old_state >>= 1; |
| 449 new_state >>= 1; | |
| 0 | 450 } |
| 4393 | 451 mouse_lost = 0; |
| 452 return; | |
| 0 | 453 } |
| 4393 | 454 |
| 455 /* Translate mouse messages */ | |
| 456 xrel = 0; | |
| 457 yrel = 0; | |
| 458 for ( i=0; i<(int)numevents; ++i ) { | |
| 459 switch (ptrbuf[i].dwOfs) { | |
| 460 case DIMOFS_X: | |
| 461 if ( timestamp != ptrbuf[i].dwTimeStamp ) { | |
| 462 if ( xrel || yrel ) { | |
| 463 post_mouse_motion(1, xrel, yrel); | |
| 464 xrel = 0; | |
| 465 yrel = 0; | |
| 466 } | |
| 467 timestamp = ptrbuf[i].dwTimeStamp; | |
| 0 | 468 } |
| 4393 | 469 xrel += (Sint16)ptrbuf[i].dwData; |
| 470 break; | |
| 471 case DIMOFS_Y: | |
| 472 if ( timestamp != ptrbuf[i].dwTimeStamp ) { | |
| 473 if ( xrel || yrel ) { | |
| 474 post_mouse_motion(1, xrel, yrel); | |
| 475 xrel = 0; | |
| 476 yrel = 0; | |
| 477 } | |
| 478 timestamp = ptrbuf[i].dwTimeStamp; | |
| 479 } | |
| 480 yrel += (Sint16)ptrbuf[i].dwData; | |
| 481 break; | |
| 482 case DIMOFS_Z: | |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
483 if ( xrel || yrel ) { |
| 4167 | 484 post_mouse_motion(1, xrel, yrel); |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
485 xrel = 0; |
|
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
486 yrel = 0; |
|
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
487 } |
| 4393 | 488 timestamp = 0; |
| 489 if((int)ptrbuf[i].dwData > 0) | |
| 490 button = SDL_BUTTON_WHEELUP; | |
| 491 else | |
| 492 button = SDL_BUTTON_WHEELDOWN; | |
| 493 posted = SDL_PrivateMouseButton( | |
| 494 SDL_PRESSED, button, 0, 0); | |
| 495 posted |= SDL_PrivateMouseButton( | |
| 496 SDL_RELEASED, button, 0, 0); | |
| 497 break; | |
| 498 case DIMOFS_BUTTON0: | |
| 499 case DIMOFS_BUTTON1: | |
| 500 case DIMOFS_BUTTON2: | |
| 501 case DIMOFS_BUTTON3: | |
| 502 #if DIRECTINPUT_VERSION >= 0x700 | |
| 503 case DIMOFS_BUTTON4: | |
| 504 case DIMOFS_BUTTON5: | |
| 505 case DIMOFS_BUTTON6: | |
| 506 case DIMOFS_BUTTON7: | |
| 507 #endif | |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
508 if ( xrel || yrel ) { |
| 4167 | 509 post_mouse_motion(1, xrel, yrel); |
|
536
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
510 xrel = 0; |
|
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
511 yrel = 0; |
|
bf7f477fb2b2
Fixed potential dropped events under DirectInput
Sam Lantinga <slouken@libsdl.org>
parents:
523
diff
changeset
|
512 } |
| 4393 | 513 timestamp = 0; |
| 514 button = (Uint8)(ptrbuf[i].dwOfs-DIMOFS_BUTTON0)+1; | |
| 515 /* Map DI button numbers to SDL */ | |
| 516 switch ( button ) { | |
| 517 case 2: button = SDL_BUTTON_RIGHT; break; | |
| 518 case 3: button = SDL_BUTTON_MIDDLE; break; | |
| 519 case 4: button = SDL_BUTTON_X1; break; | |
| 520 case 5: button = SDL_BUTTON_X2; break; | |
| 521 default: break; | |
| 0 | 522 } |
| 4393 | 523 if ( ptrbuf[i].dwData & 0x80 ) { |
| 524 /* Grab mouse so we get mouse-up */ | |
| 525 if ( ++mouse_pressed > 0 ) { | |
| 526 SetCapture(SDL_Window); | |
| 527 } | |
| 528 state = SDL_PRESSED; | |
| 529 } else { | |
| 530 /* Release mouse after all mouse-ups */ | |
| 531 if ( --mouse_pressed <= 0 ) { | |
| 532 ReleaseCapture(); | |
| 533 mouse_pressed = 0; | |
| 534 } | |
| 535 state = SDL_RELEASED; | |
| 0 | 536 } |
| 4393 | 537 if ( mouse_buttons_swapped ) { |
| 538 if ( button == 1 ) button = 3; | |
| 539 else | |
| 540 if ( button == 3 ) button = 1; | |
| 541 } | |
| 542 posted = SDL_PrivateMouseButton(state, button, | |
| 543 0, 0); | |
| 544 break; | |
| 545 } | |
| 0 | 546 } |
| 4393 | 547 if ( xrel || yrel ) { |
| 548 post_mouse_motion(1, xrel, yrel); | |
| 549 } | |
| 0 | 550 } |
| 551 } | |
| 552 | |
| 553 /* The main Win32 event handler */ | |
|
1456
84de7511f79f
Fixed a bunch of 64-bit compatibility problems
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
554 LRESULT DX5_HandleMessage(_THIS, HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) |
| 0 | 555 { |
| 556 switch (msg) { | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
557 #ifdef WM_ACTIVATEAPP |
| 0 | 558 case WM_ACTIVATEAPP: { |
| 559 int i, active; | |
| 560 | |
| 561 active = (wParam && (GetForegroundWindow() == hwnd)); | |
| 562 if ( active ) { | |
| 4383 | 563 for ( i=0; i<MAX_INPUTS; ++i ) { |
| 564 if (SDL_DIdev[i] != NULL) | |
| 565 IDirectInputDevice2_Acquire( | |
| 0 | 566 SDL_DIdev[i]); |
| 567 } | |
| 568 } else { | |
| 4383 | 569 for ( i=0; i<MAX_INPUTS; ++i ) { |
| 570 if (SDL_DIdev[i] != NULL) | |
| 571 IDirectInputDevice2_Unacquire( | |
| 0 | 572 SDL_DIdev[i]); |
| 573 } | |
| 574 mouse_lost = 1; | |
| 575 } | |
| 576 } | |
| 577 break; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
578 #endif /* WM_ACTIVATEAPP */ |
| 0 | 579 |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
580 #ifdef WM_DISPLAYCHANGE |
| 0 | 581 case WM_DISPLAYCHANGE: { |
|
1456
84de7511f79f
Fixed a bunch of 64-bit compatibility problems
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
582 WPARAM BitsPerPixel; |
| 0 | 583 WORD SizeX, SizeY; |
| 584 | |
| 585 /* Ack! The display changed size and/or depth! */ | |
| 586 SizeX = LOWORD(lParam); | |
| 587 SizeY = HIWORD(lParam); | |
| 588 BitsPerPixel = wParam; | |
| 589 /* We cause this message when we go fullscreen */ | |
| 590 } | |
| 591 break; | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
592 #endif /* WM_DISPLAYCHANGE */ |
| 0 | 593 |
| 594 /* The keyboard is handled via DirectInput */ | |
| 595 case WM_SYSKEYUP: | |
| 4171 | 596 case WM_SYSKEYDOWN: |
| 0 | 597 case WM_KEYUP: |
| 598 case WM_KEYDOWN: { | |
| 599 /* Ignore windows keyboard messages */; | |
| 600 } | |
| 601 return(0); | |
| 602 | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
603 #if defined(SC_SCREENSAVE) || defined(SC_MONITORPOWER) |
| 0 | 604 /* Don't allow screen savers or monitor power downs. |
| 605 This is because they quietly clear DirectX surfaces. | |
| 606 It would be better to allow the application to | |
| 607 decide whether or not to blow these off, but the | |
| 608 semantics of SDL_PrivateSysWMEvent() don't allow | |
| 609 the application that choice. | |
| 610 */ | |
| 611 case WM_SYSCOMMAND: { | |
| 612 if ((wParam&0xFFF0)==SC_SCREENSAVE || | |
| 613 (wParam&0xFFF0)==SC_MONITORPOWER) | |
| 614 return(0); | |
| 615 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
616 /* Fall through to default processing */ |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
617 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
618 #endif /* SC_SCREENSAVE || SC_MONITORPOWER */ |
| 0 | 619 |
| 620 default: { | |
| 621 /* Only post the event if we're watching for it */ | |
| 622 if ( SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE ) { | |
| 623 SDL_SysWMmsg wmmsg; | |
| 624 | |
| 625 SDL_VERSION(&wmmsg.version); | |
| 626 wmmsg.hwnd = hwnd; | |
| 627 wmmsg.msg = msg; | |
| 628 wmmsg.wParam = wParam; | |
| 629 wmmsg.lParam = lParam; | |
| 630 posted = SDL_PrivateSysWMEvent(&wmmsg); | |
|
145
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
61
diff
changeset
|
631 |
|
721
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
632 /* DJM: If the user isn't watching for private |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
633 messages in her SDL event loop, then pass it |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
634 along to any win32 specific window proc. |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
635 */ |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
636 } else if (userWindowProc) { |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
637 return CallWindowProc(userWindowProc, hwnd, msg, wParam, lParam); |
|
ab0656314eef
Date: Thu, 18 Sep 2003 14:24:35 -0400
Sam Lantinga <slouken@libsdl.org>
parents:
717
diff
changeset
|
638 } |
| 0 | 639 } |
| 640 break; | |
| 641 } | |
| 642 return(DefWindowProc(hwnd, msg, wParam, lParam)); | |
| 643 } | |
| 644 | |
| 645 /* This function checks the windows message queue and DirectInput and returns | |
| 646 1 if there was input, 0 if there was no input, or -1 if the application has | |
| 647 posted a quit message. | |
| 648 */ | |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
649 static int DX5_CheckInput(_THIS, int timeout, BOOL processInput) |
| 0 | 650 { |
| 651 MSG msg; | |
| 652 int i; | |
| 653 HRESULT result; | |
| 654 DWORD event; | |
| 655 | |
| 656 /* Check the normal windows queue (highest preference) */ | |
| 657 posted = 0; | |
| 658 while ( ! posted && | |
|
523
c210010f50f4
Fixed windows event handling for ActiveX controls (thanks Huib-Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
491
diff
changeset
|
659 PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) { |
|
c210010f50f4
Fixed windows event handling for ActiveX controls (thanks Huib-Jan!)
Sam Lantinga <slouken@libsdl.org>
parents:
491
diff
changeset
|
660 if ( GetMessage(&msg, NULL, 0, 0) > 0 ) { |
| 0 | 661 DispatchMessage(&msg); |
| 662 } else { | |
| 663 return(-1); | |
| 664 } | |
| 665 } | |
| 666 if ( posted ) { | |
| 667 return(1); | |
| 668 } | |
| 669 | |
| 670 /* Pump the DirectInput flow */ | |
|
4391
07b330419439
Fixed bug #849 some more:
Sam Lantinga <slouken@libsdl.org>
parents:
4384
diff
changeset
|
671 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) { |
|
4237
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
672 for ( i=0; i<MAX_INPUTS; ++i ) { |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
673 if ( SDL_DIdev[i] != NULL ) { |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
674 result = IDirectInputDevice2_Poll(SDL_DIdev[i]); |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
675 if ( (result == DIERR_INPUTLOST) || |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
676 (result == DIERR_NOTACQUIRED) ) { |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
677 if ( SDL_strcmp(inputs[i].name, "mouse") == 0 ) { |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
678 mouse_lost = 1; |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
679 } |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
680 IDirectInputDevice2_Acquire(SDL_DIdev[i]); |
|
0adda8ff43ef
Potentially fixed bug #774
Sam Lantinga <slouken@libsdl.org>
parents:
4191
diff
changeset
|
681 IDirectInputDevice2_Poll(SDL_DIdev[i]); |
| 0 | 682 } |
| 683 } | |
| 684 } | |
| 685 } | |
| 686 | |
| 687 /* Wait for messages and input events */ | |
| 688 event = MsgWaitForMultipleObjects(SDL_DIndev, SDL_DIevt, FALSE, | |
| 689 timeout, QS_ALLEVENTS); | |
| 690 if ((event >= WAIT_OBJECT_0) && (event < (WAIT_OBJECT_0+SDL_DIndev))) { | |
| 691 DWORD numevents; | |
|
1330
450721ad5436
It's now possible to build SDL without any C runtime at all on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
1312
diff
changeset
|
692 static DIDEVICEOBJECTDATA evtbuf[INPUT_QSIZE]; |
| 0 | 693 |
| 694 event -= WAIT_OBJECT_0; | |
| 695 numevents = INPUT_QSIZE; | |
| 696 result = IDirectInputDevice2_GetDeviceData( | |
| 697 SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA), | |
| 698 evtbuf, &numevents, 0); | |
| 699 if ( (result == DIERR_INPUTLOST) || | |
| 700 (result == DIERR_NOTACQUIRED) ) { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
701 if ( SDL_strcmp(inputs[event].name, "mouse") == 0 ) { |
| 0 | 702 mouse_lost = 1; |
| 703 } | |
| 704 IDirectInputDevice2_Acquire(SDL_DIdev[event]); | |
| 705 result = IDirectInputDevice2_GetDeviceData( | |
| 706 SDL_DIdev[event], sizeof(DIDEVICEOBJECTDATA), | |
| 707 evtbuf, &numevents, 0); | |
| 708 } | |
| 709 /* Handle the events */ | |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
710 if ( result == DI_OK && processInput ) { |
| 0 | 711 /* Note: This can post multiple events to event queue |
| 712 */ | |
| 713 (*SDL_DIfun[event])((int)numevents, evtbuf); | |
| 714 return(1); | |
| 715 } | |
| 716 } | |
| 717 if ( event != WAIT_TIMEOUT ) { | |
| 718 /* Maybe there was a windows message? */ | |
|
4384
6800e2560310
Fixed bugs #882 and 865, re-opening bug #634
Sam Lantinga <slouken@libsdl.org>
parents:
4383
diff
changeset
|
719 if ( PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE) ) { |
| 0 | 720 if ( GetMessage(&msg, NULL, 0, 0) > 0 ) { |
| 721 DispatchMessage(&msg); | |
| 722 } else { | |
| 723 return(-1); | |
| 724 } | |
| 725 return(1); | |
| 726 } | |
| 727 } | |
| 728 return(0); | |
| 729 } | |
| 730 | |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
731 /* Change cooperative level based on whether or not we are fullscreen */ |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
732 void DX5_DInputReset(_THIS, int fullscreen) |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
733 { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
734 DWORD level; |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
735 int i; |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
736 HRESULT result; |
|
970
fb8b91365766
Date: Tue, 19 Oct 2004 23:04:58 -0700
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
737 HWND topwnd; |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
738 |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
739 for ( i=0; i<MAX_INPUTS; ++i ) { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
740 if ( SDL_DIdev[i] != NULL ) { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
741 if ( fullscreen ) { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
742 level = inputs[i].raw_level; |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
743 } else { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
744 level = inputs[i].win_level; |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
745 } |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
746 IDirectInputDevice2_Unacquire(SDL_DIdev[i]); |
|
1115
040aa1bea9fc
Fixed mismerged patch.
Ryan C. Gordon <icculus@icculus.org>
parents:
1114
diff
changeset
|
747 topwnd = GetTopLevelParent(SDL_Window); |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
748 result = IDirectInputDevice2_SetCooperativeLevel( |
|
970
fb8b91365766
Date: Tue, 19 Oct 2004 23:04:58 -0700
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
749 SDL_DIdev[i], topwnd, level); |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
750 IDirectInputDevice2_Acquire(SDL_DIdev[i]); |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
751 if ( result != DI_OK ) { |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
752 SetDIerror( |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
753 "DirectInputDevice::SetCooperativeLevel", result); |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
754 } |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
755 } |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
756 } |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
757 mouse_lost = 1; |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
758 |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
759 /* Flush pending input */ |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
760 DX5_CheckInput(this, 0, FALSE); |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
761 } |
|
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
762 |
| 0 | 763 void DX5_PumpEvents(_THIS) |
| 764 { | |
| 765 /* Wait for messages and DirectInput */ | |
|
460
a888b3ae31ff
Reset mouse state when changing video modes
Sam Lantinga <slouken@libsdl.org>
parents:
458
diff
changeset
|
766 while ( DX5_CheckInput(this, 0, TRUE) > 0 ) { |
| 0 | 767 /* Loop and check again */; |
| 768 } | |
| 769 } | |
| 770 | |
| 771 void DX5_InitOSKeymap(_THIS) | |
| 772 { | |
|
275
53fc686e9428
Added support for the pause key under DirectX
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
773 #ifndef DIK_PAUSE |
|
53fc686e9428
Added support for the pause key under DirectX
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
774 #define DIK_PAUSE 0xC5 |
|
53fc686e9428
Added support for the pause key under DirectX
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
775 #endif |
|
327
13fc64213765
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
325
diff
changeset
|
776 #ifndef DIK_OEM_102 |
|
13fc64213765
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
325
diff
changeset
|
777 #define DIK_OEM_102 0x56 /* < > | on UK/Germany keyboards */ |
|
13fc64213765
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
325
diff
changeset
|
778 #endif |
| 0 | 779 int i; |
| 780 | |
| 781 /* Map the DIK scancodes to SDL keysyms */ | |
|
1379
c0a74f199ecf
Use only safe string functions
Sam Lantinga <slouken@libsdl.org>
parents:
1361
diff
changeset
|
782 for ( i=0; i<SDL_arraysize(DIK_keymap); ++i ) |
| 0 | 783 DIK_keymap[i] = 0; |
| 784 | |
| 785 /* Defined DIK_* constants */ | |
| 786 DIK_keymap[DIK_ESCAPE] = SDLK_ESCAPE; | |
| 787 DIK_keymap[DIK_1] = SDLK_1; | |
| 788 DIK_keymap[DIK_2] = SDLK_2; | |
| 789 DIK_keymap[DIK_3] = SDLK_3; | |
| 790 DIK_keymap[DIK_4] = SDLK_4; | |
| 791 DIK_keymap[DIK_5] = SDLK_5; | |
| 792 DIK_keymap[DIK_6] = SDLK_6; | |
| 793 DIK_keymap[DIK_7] = SDLK_7; | |
| 794 DIK_keymap[DIK_8] = SDLK_8; | |
| 795 DIK_keymap[DIK_9] = SDLK_9; | |
| 796 DIK_keymap[DIK_0] = SDLK_0; | |
| 797 DIK_keymap[DIK_MINUS] = SDLK_MINUS; | |
| 798 DIK_keymap[DIK_EQUALS] = SDLK_EQUALS; | |
| 799 DIK_keymap[DIK_BACK] = SDLK_BACKSPACE; | |
| 800 DIK_keymap[DIK_TAB] = SDLK_TAB; | |
| 801 DIK_keymap[DIK_Q] = SDLK_q; | |
| 802 DIK_keymap[DIK_W] = SDLK_w; | |
| 803 DIK_keymap[DIK_E] = SDLK_e; | |
| 804 DIK_keymap[DIK_R] = SDLK_r; | |
| 805 DIK_keymap[DIK_T] = SDLK_t; | |
| 806 DIK_keymap[DIK_Y] = SDLK_y; | |
| 807 DIK_keymap[DIK_U] = SDLK_u; | |
| 808 DIK_keymap[DIK_I] = SDLK_i; | |
| 809 DIK_keymap[DIK_O] = SDLK_o; | |
| 810 DIK_keymap[DIK_P] = SDLK_p; | |
| 811 DIK_keymap[DIK_LBRACKET] = SDLK_LEFTBRACKET; | |
| 812 DIK_keymap[DIK_RBRACKET] = SDLK_RIGHTBRACKET; | |
| 813 DIK_keymap[DIK_RETURN] = SDLK_RETURN; | |
| 814 DIK_keymap[DIK_LCONTROL] = SDLK_LCTRL; | |
| 815 DIK_keymap[DIK_A] = SDLK_a; | |
| 816 DIK_keymap[DIK_S] = SDLK_s; | |
| 817 DIK_keymap[DIK_D] = SDLK_d; | |
| 818 DIK_keymap[DIK_F] = SDLK_f; | |
| 819 DIK_keymap[DIK_G] = SDLK_g; | |
| 820 DIK_keymap[DIK_H] = SDLK_h; | |
| 821 DIK_keymap[DIK_J] = SDLK_j; | |
| 822 DIK_keymap[DIK_K] = SDLK_k; | |
| 823 DIK_keymap[DIK_L] = SDLK_l; | |
| 824 DIK_keymap[DIK_SEMICOLON] = SDLK_SEMICOLON; | |
| 825 DIK_keymap[DIK_APOSTROPHE] = SDLK_QUOTE; | |
| 826 DIK_keymap[DIK_GRAVE] = SDLK_BACKQUOTE; | |
| 827 DIK_keymap[DIK_LSHIFT] = SDLK_LSHIFT; | |
| 828 DIK_keymap[DIK_BACKSLASH] = SDLK_BACKSLASH; | |
|
1852
eb2d5480ae95
Try to keep SDL keysyms sane regardless of keyboard layout in windib target.
Ryan C. Gordon <icculus@icculus.org>
parents:
1526
diff
changeset
|
829 DIK_keymap[DIK_OEM_102] = SDLK_LESS; |
| 0 | 830 DIK_keymap[DIK_Z] = SDLK_z; |
| 831 DIK_keymap[DIK_X] = SDLK_x; | |
| 832 DIK_keymap[DIK_C] = SDLK_c; | |
| 833 DIK_keymap[DIK_V] = SDLK_v; | |
| 834 DIK_keymap[DIK_B] = SDLK_b; | |
| 835 DIK_keymap[DIK_N] = SDLK_n; | |
| 836 DIK_keymap[DIK_M] = SDLK_m; | |
| 837 DIK_keymap[DIK_COMMA] = SDLK_COMMA; | |
| 838 DIK_keymap[DIK_PERIOD] = SDLK_PERIOD; | |
| 839 DIK_keymap[DIK_SLASH] = SDLK_SLASH; | |
| 840 DIK_keymap[DIK_RSHIFT] = SDLK_RSHIFT; | |
| 841 DIK_keymap[DIK_MULTIPLY] = SDLK_KP_MULTIPLY; | |
| 842 DIK_keymap[DIK_LMENU] = SDLK_LALT; | |
| 843 DIK_keymap[DIK_SPACE] = SDLK_SPACE; | |
| 844 DIK_keymap[DIK_CAPITAL] = SDLK_CAPSLOCK; | |
| 845 DIK_keymap[DIK_F1] = SDLK_F1; | |
| 846 DIK_keymap[DIK_F2] = SDLK_F2; | |
| 847 DIK_keymap[DIK_F3] = SDLK_F3; | |
| 848 DIK_keymap[DIK_F4] = SDLK_F4; | |
| 849 DIK_keymap[DIK_F5] = SDLK_F5; | |
| 850 DIK_keymap[DIK_F6] = SDLK_F6; | |
| 851 DIK_keymap[DIK_F7] = SDLK_F7; | |
| 852 DIK_keymap[DIK_F8] = SDLK_F8; | |
| 853 DIK_keymap[DIK_F9] = SDLK_F9; | |
| 854 DIK_keymap[DIK_F10] = SDLK_F10; | |
| 855 DIK_keymap[DIK_NUMLOCK] = SDLK_NUMLOCK; | |
| 856 DIK_keymap[DIK_SCROLL] = SDLK_SCROLLOCK; | |
| 857 DIK_keymap[DIK_NUMPAD7] = SDLK_KP7; | |
| 858 DIK_keymap[DIK_NUMPAD8] = SDLK_KP8; | |
| 859 DIK_keymap[DIK_NUMPAD9] = SDLK_KP9; | |
| 860 DIK_keymap[DIK_SUBTRACT] = SDLK_KP_MINUS; | |
| 861 DIK_keymap[DIK_NUMPAD4] = SDLK_KP4; | |
| 862 DIK_keymap[DIK_NUMPAD5] = SDLK_KP5; | |
| 863 DIK_keymap[DIK_NUMPAD6] = SDLK_KP6; | |
| 864 DIK_keymap[DIK_ADD] = SDLK_KP_PLUS; | |
| 865 DIK_keymap[DIK_NUMPAD1] = SDLK_KP1; | |
| 866 DIK_keymap[DIK_NUMPAD2] = SDLK_KP2; | |
| 867 DIK_keymap[DIK_NUMPAD3] = SDLK_KP3; | |
| 868 DIK_keymap[DIK_NUMPAD0] = SDLK_KP0; | |
| 869 DIK_keymap[DIK_DECIMAL] = SDLK_KP_PERIOD; | |
| 870 DIK_keymap[DIK_F11] = SDLK_F11; | |
| 871 DIK_keymap[DIK_F12] = SDLK_F12; | |
| 872 | |
| 873 DIK_keymap[DIK_F13] = SDLK_F13; | |
| 874 DIK_keymap[DIK_F14] = SDLK_F14; | |
| 875 DIK_keymap[DIK_F15] = SDLK_F15; | |
| 876 | |
| 877 DIK_keymap[DIK_NUMPADEQUALS] = SDLK_KP_EQUALS; | |
| 878 DIK_keymap[DIK_NUMPADENTER] = SDLK_KP_ENTER; | |
| 879 DIK_keymap[DIK_RCONTROL] = SDLK_RCTRL; | |
| 880 DIK_keymap[DIK_DIVIDE] = SDLK_KP_DIVIDE; | |
| 1526 | 881 DIK_keymap[DIK_SYSRQ] = SDLK_PRINT; |
| 0 | 882 DIK_keymap[DIK_RMENU] = SDLK_RALT; |
|
290
9a02597bc1b0
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
275
diff
changeset
|
883 DIK_keymap[DIK_PAUSE] = SDLK_PAUSE; |
| 0 | 884 DIK_keymap[DIK_HOME] = SDLK_HOME; |
| 885 DIK_keymap[DIK_UP] = SDLK_UP; | |
| 886 DIK_keymap[DIK_PRIOR] = SDLK_PAGEUP; | |
| 887 DIK_keymap[DIK_LEFT] = SDLK_LEFT; | |
| 888 DIK_keymap[DIK_RIGHT] = SDLK_RIGHT; | |
| 889 DIK_keymap[DIK_END] = SDLK_END; | |
| 890 DIK_keymap[DIK_DOWN] = SDLK_DOWN; | |
| 891 DIK_keymap[DIK_NEXT] = SDLK_PAGEDOWN; | |
| 892 DIK_keymap[DIK_INSERT] = SDLK_INSERT; | |
| 893 DIK_keymap[DIK_DELETE] = SDLK_DELETE; | |
| 894 DIK_keymap[DIK_LWIN] = SDLK_LMETA; | |
| 895 DIK_keymap[DIK_RWIN] = SDLK_RMETA; | |
| 896 DIK_keymap[DIK_APPS] = SDLK_MENU; | |
| 897 } | |
| 898 | |
| 899 static SDL_keysym *TranslateKey(UINT scancode, SDL_keysym *keysym, int pressed) | |
| 900 { | |
| 901 /* Set the keysym information */ | |
| 902 keysym->scancode = (unsigned char)scancode; | |
| 903 keysym->sym = DIK_keymap[scancode]; | |
| 904 keysym->mod = KMOD_NONE; | |
| 905 keysym->unicode = 0; | |
|
1253
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
906 if ( pressed && SDL_TranslateUNICODE ) { |
| 0 | 907 UINT vkey; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
908 #ifndef NO_GETKEYBOARDSTATE |
|
1253
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
909 BYTE keystate[256]; |
|
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
910 Uint16 wchars[2]; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
911 #endif |
| 0 | 912 |
| 913 vkey = MapVirtualKey(scancode, 1); | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
914 #ifdef NO_GETKEYBOARDSTATE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
915 /* Uh oh, better hope the vkey is close enough.. */ |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
916 keysym->unicode = vkey; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
332
diff
changeset
|
917 #else |
| 0 | 918 GetKeyboardState(keystate); |
| 4170 | 919 /* Numlock isn't taken into account in ToUnicode, |
| 920 * so we handle it as a special case here */ | |
| 921 if ((keystate[VK_NUMLOCK] & 1) && vkey >= VK_NUMPAD0 && vkey <= VK_NUMPAD9) | |
| 922 { | |
| 923 keysym->unicode = vkey - VK_NUMPAD0 + '0'; | |
| 924 } | |
| 925 else if (SDL_ToUnicode(vkey, scancode, keystate, wchars, sizeof(wchars)/sizeof(wchars[0]), 0) > 0) | |
|
1253
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
926 { |
|
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
927 keysym->unicode = wchars[0]; |
| 0 | 928 } |
|
1253
7c7ddaf195bf
Implemented ToUnicode() support on Windows 95/98/ME/NT/2000/XP
Sam Lantinga <slouken@libsdl.org>
parents:
1115
diff
changeset
|
929 #endif /* NO_GETKEYBOARDSTATE */ |
| 0 | 930 } |
| 931 return(keysym); | |
| 932 } | |
| 933 | |
| 934 int DX5_CreateWindow(_THIS) | |
| 935 { | |
|
1336
3692456e7b0f
Use SDL_ prefixed versions of C library functions.
Sam Lantinga <slouken@libsdl.org>
parents:
1330
diff
changeset
|
936 char *windowid = SDL_getenv("SDL_WINDOWID"); |
| 0 | 937 int i; |
| 938 | |
| 939 /* Clear out DirectInput variables in case we fail */ | |
| 940 for ( i=0; i<MAX_INPUTS; ++i ) { | |
| 941 SDL_DIdev[i] = NULL; | |
| 942 SDL_DIevt[i] = NULL; | |
| 943 SDL_DIfun[i] = NULL; | |
| 944 } | |
| 945 | |
|
1288
ea3888b472bf
Cleaned up the app registration stuff a bit
Sam Lantinga <slouken@libsdl.org>
parents:
1280
diff
changeset
|
946 SDL_RegisterApp(NULL, 0, 0); |
|
1280
f61f045343d3
Re-query the SDL_WINDOWID each time we initialize the video
Sam Lantinga <slouken@libsdl.org>
parents:
1253
diff
changeset
|
947 |
|
f61f045343d3
Re-query the SDL_WINDOWID each time we initialize the video
Sam Lantinga <slouken@libsdl.org>
parents:
1253
diff
changeset
|
948 SDL_windowid = (windowid != NULL); |
| 0 | 949 if ( SDL_windowid ) { |
|
1456
84de7511f79f
Fixed a bunch of 64-bit compatibility problems
Sam Lantinga <slouken@libsdl.org>
parents:
1402
diff
changeset
|
950 SDL_Window = (HWND)SDL_strtoull(windowid, NULL, 0); |
|
975
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
951 if ( SDL_Window == NULL ) { |
|
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
952 SDL_SetError("Couldn't get user specified window"); |
|
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
953 return(-1); |
|
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
954 } |
|
145
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
61
diff
changeset
|
955 |
|
458
a8a0a4f19df7
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
956 /* DJM: we want all event's for the user specified |
|
975
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
957 window to be handled by SDL. |
|
458
a8a0a4f19df7
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
958 */ |
|
1472
4aac8563c296
Fixed more Win64 portability issues
Sam Lantinga <slouken@libsdl.org>
parents:
1456
diff
changeset
|
959 userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC); |
|
4aac8563c296
Fixed more Win64 portability issues
Sam Lantinga <slouken@libsdl.org>
parents:
1456
diff
changeset
|
960 SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage); |
| 0 | 961 } else { |
| 962 SDL_Window = CreateWindow(SDL_Appname, SDL_Appname, | |
| 963 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX), | |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
769
diff
changeset
|
964 CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL); |
| 0 | 965 if ( SDL_Window == NULL ) { |
| 966 SDL_SetError("Couldn't create window"); | |
| 967 return(-1); | |
| 968 } | |
| 969 ShowWindow(SDL_Window, SW_HIDE); | |
| 970 } | |
| 971 | |
| 972 /* Initialize DirectInput */ | |
| 973 if ( DX5_DInputInit(this) < 0 ) { | |
| 974 return(-1); | |
| 975 } | |
| 976 | |
| 1523 | 977 /* JC 14 Mar 2006 |
| 978 Flush the message loop or this can cause big problems later | |
| 979 Especially if the user decides to use dialog boxes or assert()! | |
| 980 */ | |
| 981 WIN_FlushMessageQueue(); | |
| 982 | |
| 0 | 983 /* Ready to roll */ |
| 984 return(0); | |
| 985 } | |
| 986 | |
| 987 void DX5_DestroyWindow(_THIS) | |
| 988 { | |
| 989 /* Close down DirectInput */ | |
| 990 DX5_DInputQuit(this); | |
| 991 | |
| 992 /* Destroy our window */ | |
|
975
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
993 if ( SDL_windowid ) { |
|
1472
4aac8563c296
Fixed more Win64 portability issues
Sam Lantinga <slouken@libsdl.org>
parents:
1456
diff
changeset
|
994 SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)userWindowProc); |
|
975
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
995 } else { |
|
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
996 DestroyWindow(SDL_Window); |
|
add87cc1de0a
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
970
diff
changeset
|
997 } |
|
1288
ea3888b472bf
Cleaned up the app registration stuff a bit
Sam Lantinga <slouken@libsdl.org>
parents:
1280
diff
changeset
|
998 SDL_UnregisterApp(); |
| 1523 | 999 |
| 1000 /* JC 14 Mar 2006 | |
| 1001 Flush the message loop or this can cause big problems later | |
| 1002 Especially if the user decides to use dialog boxes or assert()! | |
| 1003 */ | |
| 1004 WIN_FlushMessageQueue(); | |
| 0 | 1005 } |