static void Init_WGL_ARB_extensions(_THIS)
{
HWND hwnd;
HDC hdc;
HGLRC hglrc;
int pformat;
const char * (WINAPI *wglGetExtensionsStringARB)(HDC) = 0;
const char *extensions;
hwnd = CreateWindow(SDL_Appname, SDL_Appname, WS_POPUP | WS_DISABLED,
0, 0, 10, 10,
NULL, NULL, SDL_Instance, NULL);
WIN_FlushMessageQueue();
hdc = GetDC(hwnd);
pformat = ChoosePixelFormat(hdc, &GL_pfd);
SetPixelFormat(hdc, pformat, &GL_pfd);
hglrc = this->gl_data->wglCreateContext(hdc);
if ( hglrc ) {
this->gl_data->wglMakeCurrent(hdc, hglrc);
}
wglGetExtensionsStringARB = (const char * (WINAPI *)(HDC))
this->gl_data->wglGetProcAddress("wglGetExtensionsStringARB");
if( wglGetExtensionsStringARB ) {
extensions = wglGetExtensionsStringARB(hdc);
} else {
extensions = NULL;
}
this->gl_data->WGL_ARB_pixel_format = 0;
if( ExtensionSupported("WGL_ARB_pixel_format", extensions) ) {
this->gl_data->wglChoosePixelFormatARB =
(BOOL (WINAPI *)(HDC, const int *, const FLOAT *, UINT, int *, UINT *))
this->gl_data->wglGetProcAddress("wglChoosePixelFormatARB");
this->gl_data->wglGetPixelFormatAttribivARB =
(BOOL (WINAPI *)(HDC, int, int, UINT, const int *, int *))
this->gl_data->wglGetProcAddress("wglGetPixelFormatAttribivARB");
if( (this->gl_data->wglChoosePixelFormatARB != NULL) &&
(this->gl_data->wglGetPixelFormatAttribivARB != NULL) ) {
this->gl_data->WGL_ARB_pixel_format = 1;
}
}
if ( hglrc ) {
this->gl_data->wglMakeCurrent(NULL, NULL);
this->gl_data->wglDeleteContext(hglrc);
}
ReleaseDC(hwnd, hdc);
DestroyWindow(hwnd);
WIN_FlushMessageQueue();
}
static int ChoosePixelFormatARB(_THIS, const int *iAttribs, const FLOAT *fAttribs)
{
HWND hwnd;
HDC hdc;
HGLRC hglrc;
const char * (WINAPI *wglGetExtensionsStringARB)(HDC) = 0;
const char *extensions;
int pformat = 0;
UINT matches = 0;
hwnd = CreateWindow(SDL_Appname, SDL_Appname, WS_POPUP | WS_DISABLED,
0, 0, 10, 10,
NULL, NULL, SDL_Instance, NULL);
WIN_FlushMessageQueue();
hdc = GetDC(hwnd);
SetPixelFormat(hdc, ChoosePixelFormat(hdc, &GL_pfd), &GL_pfd);
hglrc = this->gl_data->wglCreateContext(hdc);
if ( hglrc ) {
this->gl_data->wglMakeCurrent(hdc, hglrc);
}
wglGetExtensionsStringARB = (const char * (WINAPI *)(HDC))
this->gl_data->wglGetProcAddress("wglGetExtensionsStringARB");
if( wglGetExtensionsStringARB ) {
extensions = wglGetExtensionsStringARB(hdc);
} else {
extensions = NULL;
}
this->gl_data->WGL_ARB_pixel_format = 0;
if( ExtensionSupported("WGL_ARB_pixel_format", extensions) ) {
BOOL (WINAPI *wglChoosePixelFormatARB)(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
wglChoosePixelFormatARB =
(BOOL (WINAPI *)(HDC, const int *, const FLOAT *, UINT, int *, UINT *))
this->gl_data->wglGetProcAddress("wglChoosePixelFormatARB");
if( wglChoosePixelFormatARB &&
wglChoosePixelFormatARB(hdc, iAttribs, fAttribs, 1, &pformat, &matches) && pformat ) {
this->gl_data->WGL_ARB_pixel_format = 1;
}
}
if ( hglrc ) {
this->gl_data->wglMakeCurrent(NULL, NULL);
this->gl_data->wglDeleteContext(hglrc);
}
ReleaseDC(hwnd, hdc);
DestroyWindow(hwnd);
WIN_FlushMessageQueue();
return pformat;
}
void DIB_DestroyWindow(_THIS)
{
if ( SDL_windowid ) {
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)userWindowProc);
} else {
DestroyWindow(SDL_Window);
}
SDL_UnregisterApp();
WIN_FlushMessageQueue();
}
/* If setting the HDC fails, we may need to recreate the window (MSDN) */
static int WIN_GL_ResetWindow(_THIS)
{
int status = 0;
#ifndef _WIN32_WCE /* FIXME WinCE needs the UNICODE version of CreateWindow() */
/* This doesn't work with DirectX code (see CVS comments) */
/* If we were passed a window, then we can't create a new one */
if ( !SDL_windowid && SDL_strcmp(this->name, "windib") == 0 ) {
/* Save the existing window attributes */
LONG style;
RECT rect = { 0, 0, 0, 0 };
style = GetWindowLong(SDL_Window, GWL_STYLE);
GetWindowRect(SDL_Window, &rect);
DestroyWindow(SDL_Window);
WIN_FlushMessageQueue();
SDL_resizing = 1;
SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
style,
rect.left, rect.top,
(rect.right-rect.left)+1,
(rect.bottom-rect.top)+1,
NULL, NULL, SDL_Instance, NULL);
WIN_FlushMessageQueue();
SDL_resizing = 0;
if ( SDL_Window ) {
this->SetCaption(this, this->wm_title, this->wm_icon);
} else {
SDL_SetError("Couldn't create window");
status = -1;
}
} else
#endif /* !_WIN32_WCE */
{
SDL_SetError("Unable to reset window for OpenGL context");
status = -1;
}
return(status);
}
void DIB_DestroyWindow(_THIS)
{
if ( SDL_windowid ) {
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)userWindowProc);
} else {
DestroyWindow(SDL_Window);
}
SDL_UnregisterApp();
/* JC 14 Mar 2006
Flush the message loop or this can cause big problems later
Especially if the user decides to use dialog boxes or assert()!
*/
WIN_FlushMessageQueue();
}
int DIB_CreateWindow(_THIS)
{
char *windowid = SDL_getenv("SDL_WINDOWID");
SDL_RegisterApp(NULL, 0, 0);
SDL_windowid = (windowid != NULL);
if ( SDL_windowid ) {
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
/* wince 2.1 does not have strtol */
wchar_t *windowid_t = SDL_malloc((SDL_strlen(windowid) + 1) * sizeof(wchar_t));
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, windowid, -1, windowid_t, SDL_strlen(windowid) + 1);
SDL_Window = (HWND)wcstol(windowid_t, NULL, 0);
SDL_free(windowid_t);
#else
SDL_Window = (HWND)SDL_strtoull(windowid, NULL, 0);
#endif
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't get user specified window");
return(-1);
}
/* DJM: we want all event's for the user specified
window to be handled by SDL.
*/
userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC);
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage);
} else {
SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX),
CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL);
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't create window");
return(-1);
}
ShowWindow(SDL_Window, SW_HIDE);
}
/* JC 14 Mar 2006
Flush the message loop or this can cause big problems later
Especially if the user decides to use dialog boxes or assert()!
*/
WIN_FlushMessageQueue();
return(0);
}
int DX5_CreateWindow(_THIS)
{
char *windowid = SDL_getenv("SDL_WINDOWID");
int i;
for ( i=0; i<MAX_INPUTS; ++i ) {
SDL_DIdev[i] = NULL;
SDL_DIevt[i] = NULL;
SDL_DIfun[i] = NULL;
}
SDL_RegisterApp(NULL, 0, 0);
SDL_windowid = (windowid != NULL);
if ( SDL_windowid ) {
SDL_Window = (HWND)((size_t)SDL_strtoull(windowid, NULL, 0));
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't get user specified window");
return(-1);
}
userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC);
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage);
} else {
SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX),
CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL);
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't create window");
return(-1);
}
ShowWindow(SDL_Window, SW_HIDE);
}
if ( DX5_DInputInit(this) < 0 ) {
return(-1);
}
WIN_FlushMessageQueue();
return(0);
}
int DIB_CreateWindow(_THIS)
{
char *windowid;
SDL_RegisterApp(NULL, 0, 0);
windowid = SDL_getenv("SDL_WINDOWID");
SDL_windowid = (windowid != NULL);
if ( SDL_windowid ) {
#if defined(_WIN32_WCE) && (_WIN32_WCE < 300)
wchar_t *windowid_t = SDL_malloc((SDL_strlen(windowid) + 1) * sizeof(wchar_t));
MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, windowid, -1, windowid_t, SDL_strlen(windowid) + 1);
SDL_Window = (HWND)wcstol(windowid_t, NULL, 0);
SDL_free(windowid_t);
#else
SDL_Window = (HWND)((size_t)SDL_strtoull(windowid, NULL, 0));
#endif
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't get user specified window");
return(-1);
}
userWindowProc = (WNDPROCTYPE)GetWindowLongPtr(SDL_Window, GWLP_WNDPROC);
SetWindowLongPtr(SDL_Window, GWLP_WNDPROC, (LONG_PTR)WinMessage);
} else {
SDL_Window = CreateWindow(SDL_Appname, SDL_Appname,
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX),
CW_USEDEFAULT, CW_USEDEFAULT, 0, 0, NULL, NULL, SDL_Instance, NULL);
if ( SDL_Window == NULL ) {
SDL_SetError("Couldn't create window");
return(-1);
}
ShowWindow(SDL_Window, SW_HIDE);
}
WIN_FlushMessageQueue();
return(0);
}
SDL_Surface *DIB_SetVideoMode(_THIS, SDL_Surface *current,
int width, int height, int bpp, Uint32 flags)
{
SDL_Surface *video;
int prev_w, prev_h;
Uint32 prev_flags;
DWORD style;
const DWORD directstyle =
(WS_POPUP);
const DWORD windowstyle =
(WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX);
const DWORD resizestyle =
(WS_THICKFRAME|WS_MAXIMIZEBOX);
int binfo_size;
BITMAPINFO *binfo;
HDC hdc;
RECT bounds;
int x, y;
Uint32 Rmask, Gmask, Bmask;
/* Clean up any GL context that may be hanging around */
if ( current->flags & SDL_OPENGL ) {
WIN_GL_ShutDown(this);
}
SDL_resizing = 1;
/* Recalculate the bitmasks if necessary */
if ( bpp == current->format->BitsPerPixel ) {
video = current;
} else {
switch (bpp) {
case 15:
case 16:
if ( DIB_SussScreenDepth() == 15 ) {
/* 5-5-5 */
Rmask = 0x00007c00;
Gmask = 0x000003e0;
Bmask = 0x0000001f;
} else {
/* 5-6-5 */
Rmask = 0x0000f800;
Gmask = 0x000007e0;
Bmask = 0x0000001f;
}
break;
case 24:
case 32:
/* GDI defined as 8-8-8 */
Rmask = 0x00ff0000;
Gmask = 0x0000ff00;
Bmask = 0x000000ff;
break;
default:
Rmask = 0x00000000;
Gmask = 0x00000000;
Bmask = 0x00000000;
break;
}
video = SDL_CreateRGBSurface(SDL_SWSURFACE,
0, 0, bpp, Rmask, Gmask, Bmask, 0);
if ( video == NULL ) {
SDL_OutOfMemory();
return(NULL);
}
}
/* Fill in part of the video surface */
prev_flags = video->flags;
prev_w = video->w;
prev_h = video->h;
video->flags = 0; /* Clear flags */
video->w = width;
video->h = height;
video->pitch = SDL_CalculatePitch(video);
/* Small fix for WinCE/Win32 - when activating window
SDL_VideoSurface is equal to zero, so activating code
is not called properly for fullscreen windows because
macros WINDIB_FULLSCREEN uses SDL_VideoSurface
*/
SDL_VideoSurface = video;
#if defined(_WIN32_WCE)
if ( flags & SDL_FULLSCREEN )
video->flags |= SDL_FULLSCREEN;
#endif
#ifndef NO_CHANGEDISPLAYSETTINGS
/* Set fullscreen mode if appropriate */
if ( (flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
DEVMODE settings;
BOOL changed;
SDL_memset(&settings, 0, sizeof(DEVMODE));
settings.dmSize = sizeof(DEVMODE);
#ifdef _WIN32_WCE
// try to rotate screen to fit requested resolution
if( this->hidden->supportRotation )
{
DWORD rotation;
// ask current mode
settings.dmFields = DM_DISPLAYORIENTATION;
ChangeDisplaySettingsEx(NULL, &settings, NULL, CDS_TEST, NULL);
rotation = settings.dmDisplayOrientation;
if( (width > GetDeviceCaps(GetDC(NULL), HORZRES))
&& (height < GetDeviceCaps(GetDC(NULL), VERTRES)))
{
switch( rotation )
{
case DMDO_0:
settings.dmDisplayOrientation = DMDO_90;
break;
case DMDO_270:
settings.dmDisplayOrientation = DMDO_180;
break;
}
if( settings.dmDisplayOrientation != rotation )
{
// go to landscape
this->hidden->origRotation = rotation;
ChangeDisplaySettingsEx(NULL,&settings,NULL,CDS_RESET,NULL);
}
}
if( (width < GetDeviceCaps(GetDC(NULL), HORZRES))
&& (height > GetDeviceCaps(GetDC(NULL), VERTRES)))
{
switch( rotation )
{
case DMDO_90:
settings.dmDisplayOrientation = DMDO_0;
break;
case DMDO_180:
settings.dmDisplayOrientation = DMDO_270;
break;
}
if( settings.dmDisplayOrientation != rotation )
{
// go to portrait
this->hidden->origRotation = rotation;
ChangeDisplaySettingsEx(NULL,&settings,NULL,CDS_RESET,NULL);
}
}
}
#endif
#ifndef _WIN32_WCE
settings.dmBitsPerPel = video->format->BitsPerPixel;
settings.dmPelsWidth = width;
settings.dmPelsHeight = height;
settings.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
if ( width <= (int)SDL_desktop_mode.dmPelsWidth &&
height <= (int)SDL_desktop_mode.dmPelsHeight ) {
settings.dmDisplayFrequency = SDL_desktop_mode.dmDisplayFrequency;
settings.dmFields |= DM_DISPLAYFREQUENCY;
}
changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
if ( ! changed && (settings.dmFields & DM_DISPLAYFREQUENCY) ) {
settings.dmFields &= ~DM_DISPLAYFREQUENCY;
changed = (ChangeDisplaySettings(&settings, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL);
}
#else
changed = 1;
#endif
if ( changed ) {
video->flags |= SDL_FULLSCREEN;
SDL_fullscreen_mode = settings;
}
}
#endif /* !NO_CHANGEDISPLAYSETTINGS */
/* Reset the palette and create a new one if necessary */
if ( grab_palette ) {
DIB_ReleaseStaticColors(SDL_Window);
grab_palette = FALSE;
}
if ( screen_pal != NULL ) {
/* RJR: March 28, 2000
delete identity palette if switching from a palettized mode */
DeleteObject(screen_pal);
screen_pal = NULL;
}
if ( screen_logpal != NULL ) {
SDL_free(screen_logpal);
screen_logpal = NULL;
}
if ( bpp <= 8 )
{
/* RJR: March 28, 2000
create identity palette switching to a palettized mode */
DIB_CreatePalette(this, bpp);
}
style = GetWindowLong(SDL_Window, GWL_STYLE);
style &= ~(resizestyle|WS_MAXIMIZE);
if ( (video->flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
style &= ~windowstyle;
style |= directstyle;
} else {
#ifndef NO_CHANGEDISPLAYSETTINGS
if ( (prev_flags & SDL_FULLSCREEN) == SDL_FULLSCREEN ) {
ChangeDisplaySettings(NULL, 0);
}
#endif
if ( flags & SDL_NOFRAME ) {
style &= ~windowstyle;
style |= directstyle;
video->flags |= SDL_NOFRAME;
} else {
style &= ~directstyle;
style |= windowstyle;
if ( flags & SDL_RESIZABLE ) {
style |= resizestyle;
video->flags |= SDL_RESIZABLE;
}
}
#if WS_MAXIMIZE
if (IsZoomed(SDL_Window)) style |= WS_MAXIMIZE;
#endif
}
/* DJM: Don't piss of anyone who has setup his own window */
if ( !SDL_windowid )
SetWindowLong(SDL_Window, GWL_STYLE, style);
/* Delete the old bitmap if necessary */
if ( screen_bmp != NULL ) {
DeleteObject(screen_bmp);
}
if ( ! (flags & SDL_OPENGL) ) {
BOOL is16bitmode = (video->format->BytesPerPixel == 2);
/* Suss out the bitmap info header */
binfo_size = sizeof(*binfo);
if( is16bitmode ) {
/* 16bit modes, palette area used for rgb bitmasks */
binfo_size += 3*sizeof(DWORD);
} else if ( video->format->palette ) {
binfo_size += video->format->palette->ncolors *
sizeof(RGBQUAD);
}
binfo = (BITMAPINFO *)SDL_malloc(binfo_size);
if ( ! binfo ) {
if ( video != current ) {
SDL_FreeSurface(video);
}
SDL_OutOfMemory();
return(NULL);
}
binfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
binfo->bmiHeader.biWidth = video->w;
binfo->bmiHeader.biHeight = -video->h; /* -ve for topdown bitmap */
binfo->bmiHeader.biPlanes = 1;
binfo->bmiHeader.biSizeImage = video->h * video->pitch;
binfo->bmiHeader.biXPelsPerMeter = 0;
binfo->bmiHeader.biYPelsPerMeter = 0;
binfo->bmiHeader.biClrUsed = 0;
binfo->bmiHeader.biClrImportant = 0;
binfo->bmiHeader.biBitCount = video->format->BitsPerPixel;
if ( is16bitmode ) {
/* BI_BITFIELDS tells CreateDIBSection about the rgb masks in the palette */
binfo->bmiHeader.biCompression = BI_BITFIELDS;
((Uint32*)binfo->bmiColors)[0] = video->format->Rmask;
((Uint32*)binfo->bmiColors)[1] = video->format->Gmask;
((Uint32*)binfo->bmiColors)[2] = video->format->Bmask;
} else {
binfo->bmiHeader.biCompression = BI_RGB; /* BI_BITFIELDS for 565 vs 555 */
if ( video->format->palette ) {
SDL_memset(binfo->bmiColors, 0,
video->format->palette->ncolors*sizeof(RGBQUAD));
}
}
/* Create the offscreen bitmap buffer */
hdc = GetDC(SDL_Window);
screen_bmp = CreateDIBSection(hdc, binfo, DIB_RGB_COLORS,
(void **)(&video->pixels), NULL, 0);
ReleaseDC(SDL_Window, hdc);
SDL_free(binfo);
if ( screen_bmp == NULL ) {
if ( video != current ) {
SDL_FreeSurface(video);
}
SDL_SetError("Couldn't create DIB section");
return(NULL);
}
this->UpdateRects = DIB_NormalUpdate;
/* Set video surface flags */
if ( screen_pal && (flags & (SDL_FULLSCREEN|SDL_HWPALETTE)) ) {
grab_palette = TRUE;
}
/* BitBlt() maps colors for us */
video->flags |= SDL_HWPALETTE;
}
#ifndef _WIN32_WCE
/* Resize the window */
if ( !SDL_windowid && !IsZoomed(SDL_Window) ) {
#else
if ( !SDL_windowid ) {
#endif
HWND top;
UINT swp_flags;
const char *window = NULL;
const char *center = NULL;
if ( video->w != prev_w || video->h != prev_h ) {
window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
center = SDL_getenv("SDL_VIDEO_CENTERED");
if ( window ) {
if ( SDL_sscanf(window, "%d,%d", &x, &y) == 2 ) {
SDL_windowX = x;
SDL_windowY = y;
}
if ( SDL_strcmp(window, "center") == 0 ) {
center = window;
}
}
}
swp_flags = (SWP_NOCOPYBITS | SWP_SHOWWINDOW);
bounds.left = SDL_windowX;
bounds.top = SDL_windowY;
bounds.right = SDL_windowX+video->w;
bounds.bottom = SDL_windowY+video->h;
#ifndef _WIN32_WCE
AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), (GetMenu(SDL_Window) != NULL), 0);
#else
// The bMenu parameter must be FALSE; menu bars are not supported
AdjustWindowRectEx(&bounds, GetWindowLong(SDL_Window, GWL_STYLE), 0, 0);
#endif
width = bounds.right-bounds.left;
height = bounds.bottom-bounds.top;
if ( (flags & SDL_FULLSCREEN) ) {
x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
} else if ( center ) {
x = (GetSystemMetrics(SM_CXSCREEN)-width)/2;
y = (GetSystemMetrics(SM_CYSCREEN)-height)/2;
} else if ( SDL_windowX || SDL_windowY || window ) {
x = bounds.left;
y = bounds.top;
} else {
x = y = -1;
swp_flags |= SWP_NOMOVE;
}
if ( flags & SDL_FULLSCREEN ) {
top = HWND_TOPMOST;
} else {
top = HWND_NOTOPMOST;
}
SetWindowPos(SDL_Window, top, x, y, width, height, swp_flags);
if ( !(flags & SDL_FULLSCREEN) ) {
SDL_windowX = SDL_bounds.left;
SDL_windowY = SDL_bounds.top;
}
SetForegroundWindow(SDL_Window);
}
SDL_resizing = 0;
/* Set up for OpenGL */
if ( flags & SDL_OPENGL ) {
if ( WIN_GL_SetupWindow(this) < 0 ) {
return(NULL);
}
video->flags |= SDL_OPENGL;
}
/* JC 14 Mar 2006
Flush the message loop or this can cause big problems later
Especially if the user decides to use dialog boxes or assert()!
*/
WIN_FlushMessageQueue();
/* We're live! */
return(video);
}
/* We don't actually allow hardware surfaces in the DIB driver */
static int DIB_AllocHWSurface(_THIS, SDL_Surface *surface)
{
return(-1);
}
static void DIB_FreeHWSurface(_THIS, SDL_Surface *surface)
{
return;
}
static int DIB_LockHWSurface(_THIS, SDL_Surface *surface)
{
return(0);
}
static void DIB_UnlockHWSurface(_THIS, SDL_Surface *surface)
{
return;
}
static void DIB_NormalUpdate(_THIS, int numrects, SDL_Rect *rects)
{
HDC hdc, mdc;
int i;
hdc = GetDC(SDL_Window);
if ( screen_pal ) {
SelectPalette(hdc, screen_pal, FALSE);
}
mdc = CreateCompatibleDC(hdc);
SelectObject(mdc, screen_bmp);
for ( i=0; i<numrects; ++i ) {
BitBlt(hdc, rects[i].x, rects[i].y, rects[i].w, rects[i].h,
mdc, rects[i].x, rects[i].y, SRCCOPY);
}
DeleteDC(mdc);
ReleaseDC(SDL_Window, hdc);
}
