Mercurial > sdl-ios-xcode
annotate src/video/windib/SDL_dibvideo.c @ 1295:c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
From: Per Inge Mathisen
Subject: [SDL] Fullscreen refresh on win32
Windows has a terrible default for fullscreen 3D apps of 60mhz refresh
rate. This can be fixed by the user by going into his driver's
control panel and forcing the refresh rate higher. However, this not a
very user friendly way about it, and in any case SDL contains no code
that could figure out this that condition has afflicted the user.
So the question is, could SDL fix this for the user? It is possible
under Windows to request a higher refresh rate. The danger is of
course that if the user has an old monitor, and you request a too high
refresh rate, the monitor could be damaged. However, I believe there
might be a way around that: Check before switching what refresh rate
the user's desktop runs in, and if our fullscreen dimensions are equal
or less than those of the desktop, use the higher refresh rate of 60
and the desktop rate.
Since most users run their desktops in the same or higher resolution
something sane, this should fix this problem for most users.
Thoughts?
An alternative is to add an SDL_GL_GetAttribute(SDL_GL_REFRESH_RATE)
option so that programs can bitch at their users at their own
convenience.
- Per
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Mon, 30 Jan 2006 06:56:10 +0000 |
| parents | 59c7a470a51e |
| children | c9b51268668f |
| 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 | |
|
252
e8157fcb3114
Updated the source with the correct e-mail address
Sam Lantinga <slouken@libsdl.org>
parents:
169
diff
changeset
|
20 slouken@libsdl.org |
| 0 | 21 */ |
| 22 | |
| 23 #ifdef SAVE_RCSID | |
| 24 static char rcsid = | |
| 25 "@(#) $Id$"; | |
| 26 #endif | |
| 27 | |
| 28 #include <stdio.h> | |
| 29 #include <stdlib.h> | |
| 30 #include <malloc.h> | |
| 31 #include <windows.h> | |
|
1152
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
32 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
33 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
34 #if defined(_WIN32_WCE) |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
35 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
36 // defined and used in SDL_sysevents.c |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
37 extern HINSTANCE aygshell; |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
38 |
|
514
1080bfc4aa96
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
39 #endif |
| 0 | 40 |
| 41 /* Not yet in the mingw32 cross-compile headers */ | |
| 42 #ifndef CDS_FULLSCREEN | |
| 43 #define CDS_FULLSCREEN 4 | |
| 44 #endif | |
| 45 | |
| 46 #include "SDL.h" | |
| 47 #include "SDL_mutex.h" | |
| 48 #include "SDL_syswm.h" | |
| 49 #include "SDL_sysvideo.h" | |
| 50 #include "SDL_sysevents.h" | |
| 51 #include "SDL_events_c.h" | |
| 52 #include "SDL_pixels_c.h" | |
| 53 #include "SDL_dibvideo.h" | |
| 54 #include "SDL_syswm_c.h" | |
| 55 #include "SDL_sysmouse_c.h" | |
| 56 #include "SDL_dibevents_c.h" | |
| 57 #include "SDL_wingl_c.h" | |
| 58 | |
| 59 #ifdef _WIN32_WCE | |
| 60 #define NO_GETDIBITS | |
| 61 #define NO_CHANGEDISPLAYSETTINGS | |
| 62 #define NO_GAMMA_SUPPORT | |
| 63 #endif | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
64 #ifndef WS_MAXIMIZE |
|
766
ed57c876700d
Date: Wed, 26 Nov 2003 01:52:02 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
515
diff
changeset
|
65 #define WS_MAXIMIZE 0 |
|
ed57c876700d
Date: Wed, 26 Nov 2003 01:52:02 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
515
diff
changeset
|
66 #endif |
|
ed57c876700d
Date: Wed, 26 Nov 2003 01:52:02 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
515
diff
changeset
|
67 #ifndef WS_THICKFRAME |
|
ed57c876700d
Date: Wed, 26 Nov 2003 01:52:02 +0800
Sam Lantinga <slouken@libsdl.org>
parents:
515
diff
changeset
|
68 #define WS_THICKFRAME 0 |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
69 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
70 #ifndef SWP_NOCOPYBITS |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
71 #define SWP_NOCOPYBITS 0 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
72 #endif |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
73 #ifndef PC_NOCOLLAPSE |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
74 #define PC_NOCOLLAPSE 0 |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
75 #endif |
| 0 | 76 |
| 77 /* Initialization/Query functions */ | |
| 78 static int DIB_VideoInit(_THIS, SDL_PixelFormat *vformat); | |
| 79 static SDL_Rect **DIB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags); | |
| 80 SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current, int width, int height, int bpp, Uint32 flags); | |
| 81 static int DIB_SetColors(_THIS, int firstcolor, int ncolors, | |
| 82 SDL_Color *colors); | |
| 83 static void DIB_CheckGamma(_THIS); | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
84 void DIB_SwapGamma(_THIS); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
85 void DIB_QuitGamma(_THIS); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
86 int DIB_SetGammaRamp(_THIS, Uint16 *ramp); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
87 int DIB_GetGammaRamp(_THIS, Uint16 *ramp); |
| 0 | 88 static void DIB_VideoQuit(_THIS); |
| 89 | |
| 90 /* Hardware surface functions */ | |
| 91 static int DIB_AllocHWSurface(_THIS, SDL_Surface *surface); | |
| 92 static int DIB_LockHWSurface(_THIS, SDL_Surface *surface); | |
| 93 static void DIB_UnlockHWSurface(_THIS, SDL_Surface *surface); | |
| 94 static void DIB_FreeHWSurface(_THIS, SDL_Surface *surface); | |
| 95 | |
| 96 /* Windows message handling functions */ | |
| 97 static void DIB_RealizePalette(_THIS); | |
| 98 static void DIB_PaletteChanged(_THIS, HWND window); | |
| 99 static void DIB_WinPAINT(_THIS, HDC hdc); | |
| 100 | |
| 101 /* helper fn */ | |
| 102 static int DIB_SussScreenDepth(); | |
| 103 | |
| 104 /* DIB driver bootstrap functions */ | |
| 105 | |
| 106 static int DIB_Available(void) | |
| 107 { | |
| 108 return(1); | |
| 109 } | |
| 110 | |
| 111 static void DIB_DeleteDevice(SDL_VideoDevice *device) | |
| 112 { | |
| 113 if ( device ) { | |
| 114 if ( device->hidden ) { | |
| 115 free(device->hidden); | |
| 116 } | |
| 117 if ( device->gl_data ) { | |
| 118 free(device->gl_data); | |
| 119 } | |
| 120 free(device); | |
| 121 } | |
| 122 } | |
| 123 | |
| 124 static SDL_VideoDevice *DIB_CreateDevice(int devindex) | |
| 125 { | |
| 126 SDL_VideoDevice *device; | |
| 127 | |
| 128 /* Initialize all variables that we clean on shutdown */ | |
| 129 device = (SDL_VideoDevice *)malloc(sizeof(SDL_VideoDevice)); | |
| 130 if ( device ) { | |
| 131 memset(device, 0, (sizeof *device)); | |
| 132 device->hidden = (struct SDL_PrivateVideoData *) | |
| 133 malloc((sizeof *device->hidden)); | |
| 134 device->gl_data = (struct SDL_PrivateGLData *) | |
| 135 malloc((sizeof *device->gl_data)); | |
| 136 } | |
| 137 if ( (device == NULL) || (device->hidden == NULL) || | |
| 138 (device->gl_data == NULL) ) { | |
| 139 SDL_OutOfMemory(); | |
| 140 DIB_DeleteDevice(device); | |
| 141 return(NULL); | |
| 142 } | |
| 143 memset(device->hidden, 0, (sizeof *device->hidden)); | |
| 144 memset(device->gl_data, 0, (sizeof *device->gl_data)); | |
| 145 | |
| 146 /* Set the function pointers */ | |
| 147 device->VideoInit = DIB_VideoInit; | |
| 148 device->ListModes = DIB_ListModes; | |
| 149 device->SetVideoMode = DIB_SetVideoMode; | |
| 150 device->UpdateMouse = WIN_UpdateMouse; | |
| 151 device->SetColors = DIB_SetColors; | |
| 152 device->UpdateRects = NULL; | |
| 153 device->VideoQuit = DIB_VideoQuit; | |
| 154 device->AllocHWSurface = DIB_AllocHWSurface; | |
| 155 device->CheckHWBlit = NULL; | |
| 156 device->FillHWRect = NULL; | |
| 157 device->SetHWColorKey = NULL; | |
| 158 device->SetHWAlpha = NULL; | |
| 159 device->LockHWSurface = DIB_LockHWSurface; | |
| 160 device->UnlockHWSurface = DIB_UnlockHWSurface; | |
| 161 device->FlipHWSurface = NULL; | |
| 162 device->FreeHWSurface = DIB_FreeHWSurface; | |
| 163 device->SetGammaRamp = DIB_SetGammaRamp; | |
| 164 device->GetGammaRamp = DIB_GetGammaRamp; | |
| 165 #ifdef HAVE_OPENGL | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
166 device->GL_LoadLibrary = WIN_GL_LoadLibrary; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
167 device->GL_GetProcAddress = WIN_GL_GetProcAddress; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
168 device->GL_GetAttribute = WIN_GL_GetAttribute; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
169 device->GL_MakeCurrent = WIN_GL_MakeCurrent; |
|
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
170 device->GL_SwapBuffers = WIN_GL_SwapBuffers; |
| 0 | 171 #endif |
| 172 device->SetCaption = WIN_SetWMCaption; | |
| 173 device->SetIcon = WIN_SetWMIcon; | |
| 174 device->IconifyWindow = WIN_IconifyWindow; | |
| 175 device->GrabInput = WIN_GrabInput; | |
| 176 device->GetWMInfo = WIN_GetWMInfo; | |
| 177 device->FreeWMCursor = WIN_FreeWMCursor; | |
| 178 device->CreateWMCursor = WIN_CreateWMCursor; | |
| 179 device->ShowWMCursor = WIN_ShowWMCursor; | |
| 180 device->WarpWMCursor = WIN_WarpWMCursor; | |
| 181 device->CheckMouseMode = WIN_CheckMouseMode; | |
| 182 device->InitOSKeymap = DIB_InitOSKeymap; | |
| 183 device->PumpEvents = DIB_PumpEvents; | |
| 184 | |
| 185 /* Set up the windows message handling functions */ | |
| 186 WIN_RealizePalette = DIB_RealizePalette; | |
| 187 WIN_PaletteChanged = DIB_PaletteChanged; | |
| 188 WIN_WinPAINT = DIB_WinPAINT; | |
| 189 HandleMessage = DIB_HandleMessage; | |
| 190 | |
| 191 device->free = DIB_DeleteDevice; | |
| 192 | |
| 193 /* We're finally ready */ | |
| 194 return device; | |
| 195 } | |
| 196 | |
| 197 VideoBootStrap WINDIB_bootstrap = { | |
|
1152
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
198 "windib", "Win95/98/NT/2000/CE GDI", |
| 0 | 199 DIB_Available, DIB_CreateDevice |
| 200 }; | |
| 201 | |
| 202 #ifndef NO_CHANGEDISPLAYSETTINGS | |
| 203 | |
| 204 static int cmpmodes(const void *va, const void *vb) | |
| 205 { | |
| 206 SDL_Rect *a = *(SDL_Rect **)va; | |
| 207 SDL_Rect *b = *(SDL_Rect **)vb; | |
|
966
f72cc0c7305f
Video modes are sorted width first, then height
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
208 if ( a->w == b->w ) |
|
f72cc0c7305f
Video modes are sorted width first, then height
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
209 return b->h - a->h; |
|
f72cc0c7305f
Video modes are sorted width first, then height
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
210 else |
|
f72cc0c7305f
Video modes are sorted width first, then height
Sam Lantinga <slouken@libsdl.org>
parents:
833
diff
changeset
|
211 return b->w - a->w; |
| 0 | 212 } |
| 213 | |
| 214 static int DIB_AddMode(_THIS, int bpp, int w, int h) | |
| 215 { | |
| 216 SDL_Rect *mode; | |
| 217 int i, index; | |
| 218 int next_mode; | |
| 219 | |
| 220 /* Check to see if we already have this mode */ | |
| 221 if ( bpp < 8 ) { /* Not supported */ | |
| 222 return(0); | |
| 223 } | |
| 224 index = ((bpp+7)/8)-1; | |
| 225 for ( i=0; i<SDL_nummodes[index]; ++i ) { | |
| 226 mode = SDL_modelist[index][i]; | |
| 227 if ( (mode->w == w) && (mode->h == h) ) { | |
| 228 return(0); | |
| 229 } | |
| 230 } | |
| 231 | |
| 232 /* Set up the new video mode rectangle */ | |
| 233 mode = (SDL_Rect *)malloc(sizeof *mode); | |
| 234 if ( mode == NULL ) { | |
| 235 SDL_OutOfMemory(); | |
| 236 return(-1); | |
| 237 } | |
| 238 mode->x = 0; | |
| 239 mode->y = 0; | |
| 240 mode->w = w; | |
| 241 mode->h = h; | |
| 242 | |
| 243 /* Allocate the new list of modes, and fill in the new mode */ | |
| 244 next_mode = SDL_nummodes[index]; | |
| 245 SDL_modelist[index] = (SDL_Rect **) | |
| 246 realloc(SDL_modelist[index], (1+next_mode+1)*sizeof(SDL_Rect *)); | |
| 247 if ( SDL_modelist[index] == NULL ) { | |
| 248 SDL_OutOfMemory(); | |
| 249 SDL_nummodes[index] = 0; | |
| 250 free(mode); | |
| 251 return(-1); | |
| 252 } | |
| 253 SDL_modelist[index][next_mode] = mode; | |
| 254 SDL_modelist[index][next_mode+1] = NULL; | |
| 255 SDL_nummodes[index]++; | |
| 256 | |
| 257 return(0); | |
| 258 } | |
| 259 | |
| 260 #endif /* !NO_CHANGEDISPLAYSETTINGS */ | |
| 261 | |
| 262 static HPALETTE DIB_CreatePalette(int bpp) | |
| 263 { | |
| 264 /* RJR: March 28, 2000 | |
| 265 moved palette creation here from "DIB_VideoInit" */ | |
| 266 | |
| 267 HPALETTE handle = NULL; | |
| 268 | |
| 269 if ( bpp <= 8 ) | |
| 270 { | |
| 271 LOGPALETTE *palette; | |
| 272 HDC hdc; | |
| 273 int ncolors; | |
| 274 int i; | |
| 275 | |
| 276 ncolors = 1; | |
| 277 for ( i=0; i<bpp; ++i ) { | |
| 278 ncolors *= 2; | |
| 279 } | |
| 280 palette = (LOGPALETTE *)malloc(sizeof(*palette)+ | |
| 281 ncolors*sizeof(PALETTEENTRY)); | |
| 282 palette->palVersion = 0x300; | |
| 283 palette->palNumEntries = ncolors; | |
| 284 hdc = GetDC(SDL_Window); | |
| 285 GetSystemPaletteEntries(hdc, 0, ncolors, palette->palPalEntry); | |
| 286 ReleaseDC(SDL_Window, hdc); | |
| 287 handle = CreatePalette(palette); | |
| 288 free(palette); | |
| 289 } | |
| 290 | |
| 291 return handle; | |
| 292 } | |
| 293 | |
| 294 int DIB_VideoInit(_THIS, SDL_PixelFormat *vformat) | |
| 295 { | |
| 296 #ifndef NO_CHANGEDISPLAYSETTINGS | |
| 297 int i; | |
| 298 DEVMODE settings; | |
| 299 #endif | |
| 300 | |
| 301 /* Create the window */ | |
| 302 if ( DIB_CreateWindow(this) < 0 ) { | |
| 303 return(-1); | |
| 304 } | |
|
169
8039a5b760b9
Allow building SDL on Windows without audio support
Sam Lantinga <slouken@libsdl.org>
parents:
145
diff
changeset
|
305 #ifndef DISABLE_AUDIO |
| 0 | 306 DX5_SoundFocus(SDL_Window); |
|
169
8039a5b760b9
Allow building SDL on Windows without audio support
Sam Lantinga <slouken@libsdl.org>
parents:
145
diff
changeset
|
307 #endif |
| 0 | 308 |
| 309 /* Determine the screen depth */ | |
| 310 vformat->BitsPerPixel = DIB_SussScreenDepth(); | |
| 311 switch (vformat->BitsPerPixel) { | |
| 312 case 15: | |
| 313 vformat->Rmask = 0x00007c00; | |
| 314 vformat->Gmask = 0x000003e0; | |
| 315 vformat->Bmask = 0x0000001f; | |
| 316 vformat->BitsPerPixel = 16; | |
| 317 break; | |
| 318 case 16: | |
| 319 vformat->Rmask = 0x0000f800; | |
| 320 vformat->Gmask = 0x000007e0; | |
| 321 vformat->Bmask = 0x0000001f; | |
| 322 break; | |
| 323 case 24: | |
| 324 case 32: | |
| 325 /* GDI defined as 8-8-8 */ | |
| 326 vformat->Rmask = 0x00ff0000; | |
| 327 vformat->Gmask = 0x0000ff00; | |
| 328 vformat->Bmask = 0x000000ff; | |
| 329 break; | |
| 330 default: | |
| 331 break; | |
| 332 } | |
| 333 | |
| 334 /* See if gamma is supported on this screen */ | |
| 335 DIB_CheckGamma(this); | |
| 336 | |
| 337 #ifndef NO_CHANGEDISPLAYSETTINGS | |
|
1295
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
338 /* Query for the desktop resolution */ |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
339 EnumDisplaySettings(NULL, ENUM_CURRENT_SETTINGS, &SDL_desktop_mode); |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
340 |
| 0 | 341 /* Query for the list of available video modes */ |
| 342 for ( i=0; EnumDisplaySettings(NULL, i, &settings); ++i ) { | |
| 343 DIB_AddMode(this, settings.dmBitsPerPel, | |
| 344 settings.dmPelsWidth, settings.dmPelsHeight); | |
| 345 } | |
| 346 /* Sort the mode lists */ | |
| 347 for ( i=0; i<NUM_MODELISTS; ++i ) { | |
| 348 if ( SDL_nummodes[i] > 0 ) { | |
| 349 qsort(SDL_modelist[i], SDL_nummodes[i], sizeof *SDL_modelist[i], cmpmodes); | |
| 350 } | |
| 351 } | |
| 352 #endif /* !NO_CHANGEDISPLAYSETTINGS */ | |
| 353 | |
| 354 /* Grab an identity palette if we are in a palettized mode */ | |
| 355 if ( vformat->BitsPerPixel <= 8 ) { | |
| 356 /* RJR: March 28, 2000 | |
| 357 moved palette creation to "DIB_CreatePalette" */ | |
| 358 screen_pal = DIB_CreatePalette(vformat->BitsPerPixel); | |
| 359 } | |
| 360 | |
| 361 /* Fill in some window manager capabilities */ | |
| 362 this->info.wm_available = 1; | |
| 363 | |
| 364 /* We're done! */ | |
| 365 return(0); | |
| 366 } | |
| 367 | |
| 368 /* We support any format at any dimension */ | |
| 369 SDL_Rect **DIB_ListModes(_THIS, SDL_PixelFormat *format, Uint32 flags) | |
| 370 { | |
| 371 #ifdef NO_CHANGEDISPLAYSETTINGS | |
| 372 return((SDL_Rect **)-1); | |
| 373 #else | |
| 374 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 375 return(SDL_modelist[((format->BitsPerPixel+7)/8)-1]); | |
| 376 } else { | |
| 377 return((SDL_Rect **)-1); | |
| 378 } | |
| 379 #endif | |
| 380 } | |
| 381 | |
| 382 | |
| 383 /* | |
| 384 Helper fn to work out which screen depth windows is currently using. | |
| 385 15 bit mode is considered 555 format, 16 bit is 565. | |
| 386 returns 0 for unknown mode. | |
| 387 (Derived from code in sept 1999 Windows Developer Journal | |
| 388 http://www.wdj.com/code/archive.html) | |
| 389 */ | |
| 390 static int DIB_SussScreenDepth() | |
| 391 { | |
| 392 #ifdef NO_GETDIBITS | |
| 393 int depth; | |
| 394 HDC hdc; | |
| 395 | |
| 396 hdc = GetDC(SDL_Window); | |
| 397 depth = GetDeviceCaps(hdc, PLANES) * GetDeviceCaps(hdc, BITSPIXEL); | |
| 398 ReleaseDC(SDL_Window, hdc); | |
| 399 return(depth); | |
| 400 #else | |
| 401 int dib_size; | |
| 402 LPBITMAPINFOHEADER dib_hdr; | |
| 403 HDC hdc; | |
| 404 HBITMAP hbm; | |
| 405 | |
| 406 /* Allocate enough space for a DIB header plus palette (for | |
| 407 * 8-bit modes) or bitfields (for 16- and 32-bit modes) | |
| 408 */ | |
| 409 dib_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof (RGBQUAD); | |
| 410 dib_hdr = (LPBITMAPINFOHEADER) malloc(dib_size); | |
| 411 memset(dib_hdr, 0, dib_size); | |
| 412 dib_hdr->biSize = sizeof(BITMAPINFOHEADER); | |
| 413 | |
| 414 /* Get a device-dependent bitmap that's compatible with the | |
| 415 screen. | |
| 416 */ | |
| 417 hdc = GetDC(NULL); | |
| 418 hbm = CreateCompatibleBitmap( hdc, 1, 1 ); | |
| 419 | |
| 420 /* Convert the DDB to a DIB. We need to call GetDIBits twice: | |
| 421 * the first call just fills in the BITMAPINFOHEADER; the | |
| 422 * second fills in the bitfields or palette. | |
| 423 */ | |
| 424 GetDIBits(hdc, hbm, 0, 1, NULL, (LPBITMAPINFO) dib_hdr, DIB_RGB_COLORS); | |
| 425 GetDIBits(hdc, hbm, 0, 1, NULL, (LPBITMAPINFO) dib_hdr, DIB_RGB_COLORS); | |
| 426 DeleteObject(hbm); | |
| 427 ReleaseDC(NULL, hdc); | |
| 428 | |
| 429 switch( dib_hdr->biBitCount ) | |
| 430 { | |
| 431 case 8: return 8; | |
| 432 case 24: return 24; | |
| 433 case 32: return 32; | |
| 434 case 16: | |
| 435 if( dib_hdr->biCompression == BI_BITFIELDS ) { | |
| 436 /* check the red mask */ | |
| 437 switch( ((DWORD*)((char*)dib_hdr + dib_hdr->biSize))[0] ) { | |
| 438 case 0xf800: return 16; /* 565 */ | |
| 439 case 0x7c00: return 15; /* 555 */ | |
| 440 } | |
| 441 } | |
| 442 } | |
| 443 return 0; /* poo. */ | |
| 444 #endif /* NO_GETDIBITS */ | |
| 445 } | |
| 446 | |
| 447 | |
| 448 /* Various screen update functions available */ | |
| 449 static void DIB_NormalUpdate(_THIS, int numrects, SDL_Rect *rects); | |
| 450 | |
| 451 SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current, | |
| 452 int width, int height, int bpp, Uint32 flags) | |
| 453 { | |
| 454 SDL_Surface *video; | |
| 455 Uint32 prev_flags; | |
| 456 DWORD style; | |
| 457 const DWORD directstyle = | |
| 458 (WS_POPUP); | |
| 459 const DWORD windowstyle = | |
| 460 (WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX); | |
| 461 const DWORD resizestyle = | |
| 462 (WS_THICKFRAME|WS_MAXIMIZEBOX); | |
| 463 int binfo_size; | |
| 464 BITMAPINFO *binfo; | |
| 465 HDC hdc; | |
| 466 RECT bounds; | |
| 467 int x, y; | |
| 468 Uint32 Rmask, Gmask, Bmask; | |
| 469 | |
| 470 /* Clean up any GL context that may be hanging around */ | |
| 471 if ( current->flags & SDL_OPENGL ) { | |
| 472 WIN_GL_ShutDown(this); | |
| 473 } | |
|
1291
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
474 SDL_resizing = 1; |
| 0 | 475 |
| 476 /* Recalculate the bitmasks if necessary */ | |
| 477 if ( bpp == current->format->BitsPerPixel ) { | |
| 478 video = current; | |
| 479 } else { | |
| 480 switch (bpp) { | |
| 481 case 15: | |
| 482 case 16: | |
| 483 if ( DIB_SussScreenDepth() == 15 ) { | |
| 484 /* 5-5-5 */ | |
| 485 Rmask = 0x00007c00; | |
| 486 Gmask = 0x000003e0; | |
| 487 Bmask = 0x0000001f; | |
| 488 } else { | |
| 489 /* 5-6-5 */ | |
| 490 Rmask = 0x0000f800; | |
| 491 Gmask = 0x000007e0; | |
| 492 Bmask = 0x0000001f; | |
| 493 } | |
| 494 break; | |
| 495 case 24: | |
| 496 case 32: | |
| 497 /* GDI defined as 8-8-8 */ | |
| 498 Rmask = 0x00ff0000; | |
| 499 Gmask = 0x0000ff00; | |
| 500 Bmask = 0x000000ff; | |
| 501 break; | |
| 502 default: | |
| 503 Rmask = 0x00000000; | |
| 504 Gmask = 0x00000000; | |
| 505 Bmask = 0x00000000; | |
| 506 break; | |
| 507 } | |
| 508 video = SDL_CreateRGBSurface(SDL_SWSURFACE, | |
| 509 0, 0, bpp, Rmask, Gmask, Bmask, 0); | |
| 510 if ( video == NULL ) { | |
| 511 SDL_OutOfMemory(); | |
| 512 return(NULL); | |
| 513 } | |
| 514 } | |
| 515 | |
| 516 /* Fill in part of the video surface */ | |
| 517 prev_flags = video->flags; | |
| 518 video->flags = 0; /* Clear flags */ | |
| 519 video->w = width; | |
| 520 video->h = height; | |
| 521 video->pitch = SDL_CalculatePitch(video); | |
| 522 | |
|
1152
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
523 /* Small fix for WinCE/Win32 - when activating window |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
524 SDL_VideoSurface is equal to zero, so activating code |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
525 is not called properly for fullscreen windows because |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
526 macros WINDIB_FULLSCREEN uses SDL_VideoSurface |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
527 */ |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
528 SDL_VideoSurface = video; |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
529 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
530 #if defined(_WIN32_WCE) |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
531 if ( flags & SDL_FULLSCREEN ) |
|
514
1080bfc4aa96
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
532 video->flags |= SDL_FULLSCREEN; |
|
1080bfc4aa96
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
453
diff
changeset
|
533 #endif |
|
1152
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
534 |
| 0 | 535 #ifndef NO_CHANGEDISPLAYSETTINGS |
| 536 /* Set fullscreen mode if appropriate */ | |
| 537 if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 538 DEVMODE settings; | |
|
1295
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
539 BOOL changed; |
| 0 | 540 |
| 541 memset(&settings, 0, sizeof(DEVMODE)); | |
| 542 settings.dmSize = sizeof(DEVMODE); | |
| 543 settings.dmBitsPerPel = video->format->BitsPerPixel; | |
| 544 settings.dmPelsWidth = width; | |
| 545 settings.dmPelsHeight = height; | |
| 546 settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL; | |
|
1295
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
547 if ( width <= SDL_desktop_mode.dmPelsWidth && height <= SDL_desktop_mode.dmPelsHeight ) { |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
548 settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency; |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
549 settings.dmFields |= DM_DISPLAYFREQUENCY; |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
550 } |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
551 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
552 if ( ! changed && (settings.dmFields & DM_DISPLAYFREQUENCY) ) { |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
553 settings.dmFields &= ~DM_DISPLAYFREQUENCY; |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
554 changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL); |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
555 } |
|
c3e36ac8a94c
Date: Sun, 6 Mar 2005 17:06:20 +0100
Sam Lantinga <slouken@libsdl.org>
parents:
1292
diff
changeset
|
556 if ( changed ) { |
| 0 | 557 video->flags |= SDL_FULLSCREEN; |
|
304
ec53caed9fb2
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
252
diff
changeset
|
558 SDL_fullscreen_mode = settings; |
| 0 | 559 } |
| 560 } | |
| 561 #endif /* !NO_CHANGEDISPLAYSETTINGS */ | |
| 562 | |
|
45
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
563 /* Reset the palette and create a new one if necessary */ |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
564 if ( screen_pal != NULL ) { |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
565 /* RJR: March 28, 2000 |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
566 delete identity palette if switching from a palettized mode */ |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
567 DeleteObject(screen_pal); |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
568 screen_pal = NULL; |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
569 } |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
570 if ( bpp <= 8 ) |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
571 { |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
572 /* RJR: March 28, 2000 |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
573 create identity palette switching to a palettized mode */ |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
574 screen_pal = DIB_CreatePalette(bpp); |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
575 } |
|
60a6e045808e
Fix palette creation in windowed mode at 8 bpp
Sam Lantinga <slouken@lokigames.com>
parents:
36
diff
changeset
|
576 |
| 0 | 577 style = GetWindowLong(SDL_Window, GWL_STYLE); |
| 578 style &= ~(resizestyle|WS_MAXIMIZE); | |
| 579 if ( (video->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 580 style &= ~windowstyle; | |
| 581 style |= directstyle; | |
| 582 } else { | |
| 583 #ifndef NO_CHANGEDISPLAYSETTINGS | |
| 584 if ( (prev_flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) { | |
| 585 ChangeDisplaySettings(NULL, 0); | |
| 586 } | |
| 587 #endif | |
| 588 if ( flags & SDL_NOFRAME ) { | |
| 589 style &= ~windowstyle; | |
| 590 style |= directstyle; | |
| 591 video->flags |= SDL_NOFRAME; | |
| 592 } else { | |
| 593 style &= ~directstyle; | |
| 594 style |= windowstyle; | |
| 595 if ( flags & SDL_RESIZABLE ) { | |
| 596 style |= resizestyle; | |
| 597 video->flags |= SDL_RESIZABLE; | |
| 598 } | |
| 599 } | |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
600 #if WS_MAXIMIZE |
| 0 | 601 if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE; |
|
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
602 #endif |
| 0 | 603 } |
|
145
29a638dc26db
Applied David MacCormack's patch to fix SDL_WINDOWID on Windows,
Sam Lantinga <slouken@libsdl.org>
parents:
112
diff
changeset
|
604 |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
605 /* DJM: Don't piss of anyone who has setup his own window */ |
|
1280
f61f045343d3
Re-query the SDL_WINDOWID each time we initialize the video
Sam Lantinga <slouken@libsdl.org>
parents:
1251
diff
changeset
|
606 if ( !SDL_windowid ) |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
607 SetWindowLong(SDL_Window, GWL_STYLE, style); |
| 0 | 608 |
| 609 /* Delete the old bitmap if necessary */ | |
| 610 if ( screen_bmp != NULL ) { | |
| 611 DeleteObject(screen_bmp); | |
| 612 } | |
| 613 if ( ! (flags & SDL_OPENGL) ) { | |
| 614 BOOL is16bitmode = (video->format->BytesPerPixel == 2); | |
| 615 | |
| 616 /* Suss out the bitmap info header */ | |
| 617 binfo_size = sizeof(*binfo); | |
| 618 if( is16bitmode ) { | |
| 619 /* 16bit modes, palette area used for rgb bitmasks */ | |
| 620 binfo_size += 3*sizeof(DWORD); | |
| 621 } else if ( video->format->palette ) { | |
| 622 binfo_size += video->format->palette->ncolors * | |
| 623 sizeof(RGBQUAD); | |
| 624 } | |
| 625 binfo = (BITMAPINFO *)malloc(binfo_size); | |
| 626 if ( ! binfo ) { | |
| 627 if ( video != current ) { | |
| 628 SDL_FreeSurface(video); | |
| 629 } | |
| 630 SDL_OutOfMemory(); | |
| 631 return(NULL); | |
| 632 } | |
| 633 | |
| 634 binfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); | |
| 635 binfo->bmiHeader.biWidth = video->w; | |
| 636 binfo->bmiHeader.biHeight = -video->h; /* -ve for topdown bitmap */ | |
| 637 binfo->bmiHeader.biPlanes = 1; | |
| 638 binfo->bmiHeader.biSizeImage = video->h * video->pitch; | |
| 639 binfo->bmiHeader.biXPelsPerMeter = 0; | |
| 640 binfo->bmiHeader.biYPelsPerMeter = 0; | |
| 641 binfo->bmiHeader.biClrUsed = 0; | |
| 642 binfo->bmiHeader.biClrImportant = 0; | |
| 643 binfo->bmiHeader.biBitCount = video->format->BitsPerPixel; | |
| 644 | |
| 645 if ( is16bitmode ) { | |
| 646 /* BI_BITFIELDS tells CreateDIBSection about the rgb masks in the palette */ | |
| 647 binfo->bmiHeader.biCompression = BI_BITFIELDS; | |
| 648 ((Uint32*)binfo->bmiColors)[0] = video->format->Rmask; | |
| 649 ((Uint32*)binfo->bmiColors)[1] = video->format->Gmask; | |
| 650 ((Uint32*)binfo->bmiColors)[2] = video->format->Bmask; | |
| 651 } else { | |
| 652 binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */ | |
| 653 if ( video->format->palette ) { | |
| 654 memset(binfo->bmiColors, 0, | |
| 655 video->format->palette->ncolors*sizeof(RGBQUAD)); | |
| 656 } | |
| 657 } | |
| 658 | |
| 659 /* Create the offscreen bitmap buffer */ | |
| 660 hdc = GetDC(SDL_Window); | |
| 661 screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS, | |
| 662 (void **)(&video->pixels), NULL, 0); | |
| 663 ReleaseDC(SDL_Window, hdc); | |
| 664 free(binfo); | |
| 665 if ( screen_bmp == NULL ) { | |
| 666 if ( video != current ) { | |
| 667 SDL_FreeSurface(video); | |
| 668 } | |
| 669 SDL_SetError("Couldn't create DIB section"); | |
| 670 return(NULL); | |
| 671 } | |
| 672 this->UpdateRects = DIB_NormalUpdate; | |
| 673 | |
| 674 /* Set video surface flags */ | |
| 675 if ( bpp <= 8 ) { | |
| 676 /* BitBlt() maps colors for us */ | |
| 677 video->flags |= SDL_HWPALETTE; | |
| 678 } | |
| 679 } | |
| 680 | |
| 681 /* Resize the window */ | |
|
1290
c4a5a772c5d9
The event code was fine, and calculated the SDL_windowX/Y correctly.
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
682 if ( !SDL_windowid && !IsZoomed(SDL_Window) ) { |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
683 HWND top; |
| 0 | 684 UINT swp_flags; |
|
1290
c4a5a772c5d9
The event code was fine, and calculated the SDL_windowX/Y correctly.
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
685 const char *window = NULL; |
|
c4a5a772c5d9
The event code was fine, and calculated the SDL_windowX/Y correctly.
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
686 const char *center = NULL; |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
687 |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
688 if ( !SDL_windowX && !SDL_windowY ) { |
|
1290
c4a5a772c5d9
The event code was fine, and calculated the SDL_windowX/Y correctly.
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
689 window = getenv("SDL_VIDEO_WINDOW_POS"); |
|
c4a5a772c5d9
The event code was fine, and calculated the SDL_windowX/Y correctly.
Sam Lantinga <slouken@libsdl.org>
parents:
1288
diff
changeset
|
690 center = getenv("SDL_VIDEO_CENTERED"); |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
691 if ( window ) { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
692 if ( sscanf(window, "%d,%d", &x, &y) == 2 ) { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
693 SDL_windowX = x; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
694 SDL_windowY = y; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
695 } |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
696 if ( strcmp(window, "center") == 0 ) { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
697 center = window; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
698 } |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
699 } |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
700 } |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
701 swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW); |
| 0 | 702 |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
703 bounds.left = SDL_windowX; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
704 bounds.top = SDL_windowY; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
705 bounds.right = SDL_windowX+video->w; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
706 bounds.bottom = SDL_windowY+video->h; |
|
453
a6fa62b1be09
Updated for embedded Visual C++ 4.0
Sam Lantinga <slouken@libsdl.org>
parents:
448
diff
changeset
|
707 AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), FALSE, 0); |
| 0 | 708 width = bounds.right-bounds.left; |
| 709 height = bounds.bottom-bounds.top; | |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
710 if ( (flags & SDL_FULLSCREEN) ) { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
711 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
712 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; |
|
971
96671ebc50a4
Date: Mon, 25 Oct 2004 17:30:06 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
966
diff
changeset
|
713 } else if ( center ) { |
|
96671ebc50a4
Date: Mon, 25 Oct 2004 17:30:06 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
966
diff
changeset
|
714 x = (GetSystemMetrics(SM_CXSCREEN)-width)/2; |
|
96671ebc50a4
Date: Mon, 25 Oct 2004 17:30:06 +0200
Sam Lantinga <slouken@libsdl.org>
parents:
966
diff
changeset
|
715 y = (GetSystemMetrics(SM_CYSCREEN)-height)/2; |
|
833
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
716 } else if ( SDL_windowX || SDL_windowY || window ) { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
717 x = bounds.left; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
718 y = bounds.top; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
719 } else { |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
720 x = y = -1; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
721 swp_flags |= SWP_NOMOVE; |
|
31fa08b36380
Added support for SDL_VIDEO_WINDOW_POS and SDL_VIDEO_CENTERED on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
766
diff
changeset
|
722 } |
|
448
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
723 if ( flags & SDL_FULLSCREEN ) { |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
724 top = HWND_TOPMOST; |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
725 } else { |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
726 top = HWND_NOTOPMOST; |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
727 } |
|
323c766f5a46
Fullscreen windows are always topmost under Windows
Sam Lantinga <slouken@libsdl.org>
parents:
442
diff
changeset
|
728 SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags); |
|
1291
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
729 if ( !(flags & SDL_FULLSCREEN) ) { |
|
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
730 SDL_windowX = SDL_bounds.left; |
|
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
731 SDL_windowY = SDL_bounds.top; |
|
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
732 } |
| 0 | 733 SetForegroundWindow(SDL_Window); |
| 734 } | |
|
1291
31331c444ea2
Only save the window position if we're in windowed mode
Sam Lantinga <slouken@libsdl.org>
parents:
1290
diff
changeset
|
735 SDL_resizing = 0; |
| 0 | 736 |
| 737 /* Set up for OpenGL */ | |
| 738 if ( flags & SDL_OPENGL ) { | |
| 739 if ( WIN_GL_SetupWindow(this) < 0 ) { | |
| 740 return(NULL); | |
| 741 } | |
| 742 video->flags |= SDL_OPENGL; | |
| 743 } | |
|
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
744 |
| 0 | 745 /* We're live! */ |
| 746 return(video); | |
| 747 } | |
| 748 | |
| 749 /* We don't actually allow hardware surfaces in the DIB driver */ | |
| 750 static int DIB_AllocHWSurface(_THIS, SDL_Surface *surface) | |
| 751 { | |
| 752 return(-1); | |
| 753 } | |
| 754 static void DIB_FreeHWSurface(_THIS, SDL_Surface *surface) | |
| 755 { | |
| 756 return; | |
| 757 } | |
| 758 static int DIB_LockHWSurface(_THIS, SDL_Surface *surface) | |
| 759 { | |
| 760 return(0); | |
| 761 } | |
| 762 static void DIB_UnlockHWSurface(_THIS, SDL_Surface *surface) | |
| 763 { | |
| 764 return; | |
| 765 } | |
| 766 | |
| 767 static void DIB_NormalUpdate(_THIS, int numrects, SDL_Rect *rects) | |
| 768 { | |
| 769 HDC hdc, mdc; | |
| 770 int i; | |
| 771 | |
| 772 hdc = GetDC(SDL_Window); | |
| 773 if ( screen_pal ) { | |
| 774 SelectPalette(hdc, screen_pal, FALSE); | |
| 775 } | |
| 776 mdc = CreateCompatibleDC(hdc); | |
| 777 SelectObject(mdc, screen_bmp); | |
| 778 for ( i=0; i<numrects; ++i ) { | |
| 779 BitBlt(hdc, rects[i].x, rects[i].y, rects[i].w, rects[i].h, | |
| 780 mdc, rects[i].x, rects[i].y, SRCCOPY); | |
| 781 } | |
| 782 DeleteDC(mdc); | |
| 783 ReleaseDC(SDL_Window, hdc); | |
| 784 } | |
| 785 | |
|
1251
86d0d01290ea
Updated Windows CE/PocketPC support...adds GAPI driver, landscape mode,
Ryan C. Gordon <icculus@icculus.org>
parents:
1152
diff
changeset
|
786 |
| 0 | 787 int DIB_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors) |
| 788 { | |
|
1292
59c7a470a51e
Fixed palette bug on non-WinCE
Sam Lantinga <slouken@libsdl.org>
parents:
1291
diff
changeset
|
789 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400) |
|
59c7a470a51e
Fixed palette bug on non-WinCE
Sam Lantinga <slouken@libsdl.org>
parents:
1291
diff
changeset
|
790 HDC hdc, mdc; |
| 0 | 791 RGBQUAD *pal; |
|
1292
59c7a470a51e
Fixed palette bug on non-WinCE
Sam Lantinga <slouken@libsdl.org>
parents:
1291
diff
changeset
|
792 #else |
|
1251
86d0d01290ea
Updated Windows CE/PocketPC support...adds GAPI driver, landscape mode,
Ryan C. Gordon <icculus@icculus.org>
parents:
1152
diff
changeset
|
793 HDC hdc; |
|
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
794 #endif |
|
1292
59c7a470a51e
Fixed palette bug on non-WinCE
Sam Lantinga <slouken@libsdl.org>
parents:
1291
diff
changeset
|
795 int i; |
| 0 | 796 |
| 797 /* Update the display palette */ | |
| 798 hdc = GetDC(SDL_Window); | |
| 799 if ( screen_pal ) { | |
| 800 PALETTEENTRY *entries; | |
| 801 | |
| 802 entries = (PALETTEENTRY *)alloca(ncolors*sizeof(PALETTEENTRY)); | |
| 803 for ( i=0; i<ncolors; ++i ) { | |
| 804 entries[i].peRed = colors[i].r; | |
| 805 entries[i].peGreen = colors[i].g; | |
| 806 entries[i].peBlue = colors[i].b; | |
| 807 entries[i].peFlags = PC_NOCOLLAPSE; | |
| 808 } | |
| 809 SetPaletteEntries(screen_pal, firstcolor, ncolors, entries); | |
| 810 SelectPalette(hdc, screen_pal, FALSE); | |
| 811 RealizePalette(hdc); | |
| 812 } | |
| 813 | |
|
1292
59c7a470a51e
Fixed palette bug on non-WinCE
Sam Lantinga <slouken@libsdl.org>
parents:
1291
diff
changeset
|
814 #if !defined(_WIN32_WCE) || (_WIN32_WCE >= 400) |
| 0 | 815 /* Copy palette colors into DIB palette */ |
| 816 pal = (RGBQUAD *)alloca(ncolors*sizeof(RGBQUAD)); | |
| 817 for ( i=0; i<ncolors; ++i ) { | |
| 818 pal[i].rgbRed = colors[i].r; | |
| 819 pal[i].rgbGreen = colors[i].g; | |
| 820 pal[i].rgbBlue = colors[i].b; | |
| 821 pal[i].rgbReserved = 0; | |
| 822 } | |
| 823 | |
| 824 /* Set the DIB palette and update the display */ | |
| 825 mdc = CreateCompatibleDC(hdc); | |
| 826 SelectObject(mdc, screen_bmp); | |
| 827 SetDIBColorTable(mdc, firstcolor, ncolors, pal); | |
| 828 BitBlt(hdc, 0, 0, this->screen->w, this->screen->h, | |
| 829 mdc, 0, 0, SRCCOPY); | |
| 830 DeleteDC(mdc); | |
|
36
13ee9f4834ea
Windows CE patches contributed by Rainer Loritz
Sam Lantinga <slouken@lokigames.com>
parents:
0
diff
changeset
|
831 #endif |
| 0 | 832 ReleaseDC(SDL_Window, hdc); |
| 833 return(1); | |
| 834 } | |
| 835 | |
|
1251
86d0d01290ea
Updated Windows CE/PocketPC support...adds GAPI driver, landscape mode,
Ryan C. Gordon <icculus@icculus.org>
parents:
1152
diff
changeset
|
836 |
| 0 | 837 static void DIB_CheckGamma(_THIS) |
| 838 { | |
| 839 #ifndef NO_GAMMA_SUPPORT | |
| 840 HDC hdc; | |
| 841 WORD ramp[3*256]; | |
| 842 | |
| 843 /* If we fail to get gamma, disable gamma control */ | |
| 844 hdc = GetDC(SDL_Window); | |
| 845 if ( ! GetDeviceGammaRamp(hdc, ramp) ) { | |
| 846 this->GetGammaRamp = NULL; | |
| 847 this->SetGammaRamp = NULL; | |
| 848 } | |
| 849 ReleaseDC(SDL_Window, hdc); | |
| 850 #endif /* !NO_GAMMA_SUPPORT */ | |
| 851 } | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
852 void DIB_SwapGamma(_THIS) |
| 0 | 853 { |
| 854 #ifndef NO_GAMMA_SUPPORT | |
| 855 HDC hdc; | |
| 856 | |
| 857 if ( gamma_saved ) { | |
| 858 hdc = GetDC(SDL_Window); | |
| 859 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) { | |
| 860 /* About to leave active state, restore gamma */ | |
| 861 SetDeviceGammaRamp(hdc, gamma_saved); | |
| 862 } else { | |
| 863 /* About to enter active state, set game gamma */ | |
| 864 GetDeviceGammaRamp(hdc, gamma_saved); | |
| 865 SetDeviceGammaRamp(hdc, this->gamma); | |
| 866 } | |
| 867 ReleaseDC(SDL_Window, hdc); | |
| 868 } | |
| 869 #endif /* !NO_GAMMA_SUPPORT */ | |
| 870 } | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
871 void DIB_QuitGamma(_THIS) |
| 0 | 872 { |
| 873 #ifndef NO_GAMMA_SUPPORT | |
| 874 if ( gamma_saved ) { | |
| 875 /* Restore the original gamma if necessary */ | |
| 876 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) { | |
| 877 HDC hdc; | |
| 878 | |
| 879 hdc = GetDC(SDL_Window); | |
| 880 SetDeviceGammaRamp(hdc, gamma_saved); | |
| 881 ReleaseDC(SDL_Window, hdc); | |
| 882 } | |
| 883 | |
| 884 /* Free the saved gamma memory */ | |
| 885 free(gamma_saved); | |
| 886 gamma_saved = 0; | |
| 887 } | |
| 888 #endif /* !NO_GAMMA_SUPPORT */ | |
| 889 } | |
| 890 | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
891 int DIB_SetGammaRamp(_THIS, Uint16 *ramp) |
| 0 | 892 { |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
893 #ifdef NO_GAMMA_SUPPORT |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
894 SDL_SetError("SDL compiled without gamma ramp support"); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
895 return -1; |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
896 #else |
| 0 | 897 HDC hdc; |
| 898 BOOL succeeded; | |
| 899 | |
| 900 /* Set the ramp for the display */ | |
| 901 if ( ! gamma_saved ) { | |
| 902 gamma_saved = (WORD *)malloc(3*256*sizeof(*gamma_saved)); | |
| 903 if ( ! gamma_saved ) { | |
| 904 SDL_OutOfMemory(); | |
| 905 return -1; | |
| 906 } | |
| 907 hdc = GetDC(SDL_Window); | |
| 908 GetDeviceGammaRamp(hdc, gamma_saved); | |
| 909 ReleaseDC(SDL_Window, hdc); | |
| 910 } | |
| 911 if ( SDL_GetAppState() & SDL_APPINPUTFOCUS ) { | |
| 912 hdc = GetDC(SDL_Window); | |
| 913 succeeded = SetDeviceGammaRamp(hdc, ramp); | |
| 914 ReleaseDC(SDL_Window, hdc); | |
| 915 } else { | |
| 916 succeeded = TRUE; | |
| 917 } | |
| 918 return succeeded ? 0 : -1; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
919 #endif /* !NO_GAMMA_SUPPORT */ |
| 0 | 920 } |
| 921 | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
922 int DIB_GetGammaRamp(_THIS, Uint16 *ramp) |
| 0 | 923 { |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
924 #ifdef NO_GAMMA_SUPPORT |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
925 SDL_SetError("SDL compiled without gamma ramp support"); |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
926 return -1; |
|
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
927 #else |
| 0 | 928 HDC hdc; |
| 929 BOOL succeeded; | |
| 930 | |
| 931 /* Get the ramp from the display */ | |
| 932 hdc = GetDC(SDL_Window); | |
| 933 succeeded = GetDeviceGammaRamp(hdc, ramp); | |
| 934 ReleaseDC(SDL_Window, hdc); | |
| 935 return succeeded ? 0 : -1; | |
|
338
518ffd98a8f6
Fixed gamma ramps in DirectX windowed and OpenGL modes
Sam Lantinga <slouken@libsdl.org>
parents:
304
diff
changeset
|
936 #endif /* !NO_GAMMA_SUPPORT */ |
| 0 | 937 } |
| 938 | |
|
442
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
939 static void FlushMessageQueue() |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
940 { |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
941 MSG msg; |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
942 while ( PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) ) { |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
943 if ( msg.message == WM_QUIT ) break; |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
944 TranslateMessage( &msg ); |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
945 DispatchMessage( &msg ); |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
946 } |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
947 } |
|
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
948 |
| 0 | 949 void DIB_VideoQuit(_THIS) |
| 950 { | |
| 951 /* Destroy the window and everything associated with it */ | |
| 952 if ( SDL_Window ) { | |
| 953 /* Delete the screen bitmap (also frees screen->pixels) */ | |
| 954 if ( this->screen ) { | |
| 955 #ifndef NO_CHANGEDISPLAYSETTINGS | |
| 956 if ( this->screen->flags & SDL_FULLSCREEN ) { | |
| 957 ChangeDisplaySettings(NULL, 0); | |
|
376
a5f60a847a89
*** empty log message ***
Sam Lantinga <slouken@libsdl.org>
parents:
374
diff
changeset
|
958 ShowWindow(SDL_Window, SW_HIDE); |
| 0 | 959 } |
| 960 #endif | |
| 961 if ( this->screen->flags & SDL_OPENGL ) { | |
| 962 WIN_GL_ShutDown(this); | |
| 963 } | |
| 964 this->screen->pixels = NULL; | |
| 965 } | |
| 966 if ( screen_bmp ) { | |
| 967 DeleteObject(screen_bmp); | |
| 968 screen_bmp = NULL; | |
| 969 } | |
| 970 if ( screen_icn ) { | |
| 971 DestroyIcon(screen_icn); | |
| 972 screen_icn = NULL; | |
| 973 } | |
| 974 DIB_QuitGamma(this); | |
| 975 DIB_DestroyWindow(this); | |
|
442
b37ce4813ad4
Flush message queue when shutting down video mode on Windows
Sam Lantinga <slouken@libsdl.org>
parents:
376
diff
changeset
|
976 FlushMessageQueue(); |
| 0 | 977 |
| 978 SDL_Window = NULL; | |
|
1152
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
979 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
980 #if defined(_WIN32_WCE) |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
981 |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
982 // Unload wince aygshell library to prevent leak |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
983 if( aygshell ) |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
984 { |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
985 FreeLibrary(aygshell); |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
986 aygshell = NULL; |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
987 } |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
988 #endif |
|
51a8702d8ecd
Updates to PocketPC (WinCE) support, thanks to Dmitry Yakimov at
Ryan C. Gordon <icculus@icculus.org>
parents:
1145
diff
changeset
|
989 |
| 0 | 990 } |
| 991 } | |
| 992 | |
| 993 /* Exported for the windows message loop only */ | |
| 994 static void DIB_FocusPalette(_THIS, int foreground) | |
| 995 { | |
| 996 if ( screen_pal != NULL ) { | |
| 997 HDC hdc; | |
| 998 | |
| 999 hdc = GetDC(SDL_Window); | |
| 1000 SelectPalette(hdc, screen_pal, FALSE); | |
| 1001 if ( RealizePalette(hdc) ) | |
| 1002 InvalidateRect(SDL_Window, NULL, FALSE); | |
| 1003 ReleaseDC(SDL_Window, hdc); | |
| 1004 } | |
| 1005 } | |
| 1006 static void DIB_RealizePalette(_THIS) | |
| 1007 { | |
| 1008 DIB_FocusPalette(this, 1); | |
| 1009 } | |
| 1010 static void DIB_PaletteChanged(_THIS, HWND window) | |
| 1011 { | |
| 1012 if ( window != SDL_Window ) { | |
| 1013 DIB_FocusPalette(this, 0); | |
| 1014 } | |
| 1015 } | |
| 1016 | |
| 1017 /* Exported for the windows message loop only */ | |
| 1018 static void DIB_WinPAINT(_THIS, HDC hdc) | |
| 1019 { | |
| 1020 HDC mdc; | |
| 1021 | |
| 1022 if ( screen_pal ) { | |
| 1023 SelectPalette(hdc, screen_pal, FALSE); | |
| 1024 } | |
| 1025 mdc = CreateCompatibleDC(hdc); | |
| 1026 SelectObject(mdc, screen_bmp); | |
| 1027 BitBlt(hdc, 0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h, | |
| 1028 mdc, 0, 0, SRCCOPY); | |
| 1029 DeleteDC(mdc); | |
| 1030 } | |
| 1031 | |
| 1032 /* Stub in case DirectX isn't available */ | |
| 1033 #ifndef ENABLE_DIRECTX | |
| 1034 void DX5_SoundFocus(HWND hwnd) | |
| 1035 { | |
| 1036 return; | |
| 1037 } | |
| 1038 #endif |