Simple DirectMedia Layer

Copyright (C) 1997-2011 Sam Lantinga <slouken@libsdl.org>

This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include "SDL_config.h"

#include "../SDL_sysvideo.h"

#include "../../events/SDL_keyboard_c.h"

#include "SDL_windowsvideo.h"

#include "SDL_windowswindow.h"

#include "SDL_syswm.h"

/* Windows CE compatibility */

#ifndef SWP_NOCOPYBITS

#define SWP_NOCOPYBITS 0

#endif

/* Fake window to help with DirectInput events. */

HWND SDL_HelperWindow = NULL;

static WCHAR *SDL_HelperWindowClassName = TEXT("SDLHelperWindowInputCatcher");

static WCHAR *SDL_HelperWindowName = TEXT("SDLHelperWindowInputMsgWindow");

static ATOM SDL_HelperWindowClass = 0;

#define STYLE_BASIC (WS_CLIPSIBLINGS | WS_CLIPCHILDREN)

#define STYLE_FULLSCREEN (WS_POPUP)

#define STYLE_BORDERLESS (WS_POPUP)

#define STYLE_NORMAL (WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX)

#define STYLE_RESIZABLE (WS_THICKFRAME | WS_MAXIMIZEBOX)

#define STYLE_MASK (STYLE_FULLSCREEN | STYLE_BORDERLESS | STYLE_NORMAL | STYLE_RESIZABLE)

static DWORD

GetWindowStyle(SDL_Window * window)

{

DWORD style = 0;

if (window->flags & SDL_WINDOW_FULLSCREEN) {

style |= STYLE_FULLSCREEN;

} else {

if (window->flags & SDL_WINDOW_BORDERLESS) {

style |= STYLE_BORDERLESS;

} else {

style |= STYLE_NORMAL;

}

if (window->flags & SDL_WINDOW_RESIZABLE) {

style |= STYLE_RESIZABLE;

}

}

return style;

}

SDL_WindowData *data;

/* Allocate the window data */

data = (SDL_WindowData *) SDL_malloc(sizeof(*data));

if (!data) {

SDL_OutOfMemory();

return -1;

}

data->created = created;

data->mouse_pressed = SDL_FALSE;

/* Associate the data with the window */

if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) {

SDL_free(data);

WIN_SetError("SetProp() failed");

return -1;

}

/* Set up the window proc function */

SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc);

}

#else

data->wndproc = (WNDPROC) GetWindowLong(hwnd, GWL_WNDPROC);

if (data->wndproc == WIN_WindowProc) {

data->wndproc = NULL;

} else {

SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR) WIN_WindowProc);

}

#endif

/* Fill in the SDL window with the window data */

{

POINT point;

point.x = 0;

point.y = 0;

if (ClientToScreen(hwnd, &point)) {

window->x = point.x;

window->y = point.y;

}

}

{

RECT rect;

if (GetClientRect(hwnd, &rect)) {

window->w = rect.right;

window->h = rect.bottom;

}

}

{

DWORD style = GetWindowLong(hwnd, GWL_STYLE);

if (style & WS_VISIBLE) {

window->flags |= SDL_WINDOW_SHOWN;

} else {

window->flags &= ~SDL_WINDOW_SHOWN;

}

if (style & (WS_BORDER | WS_THICKFRAME)) {

window->flags &= ~SDL_WINDOW_BORDERLESS;

} else {

window->flags |= SDL_WINDOW_BORDERLESS;

}

if (style & WS_THICKFRAME) {

window->flags |= SDL_WINDOW_RESIZABLE;

} else {

window->flags &= ~SDL_WINDOW_RESIZABLE;

}

if (style & WS_MAXIMIZE) {

window->flags |= SDL_WINDOW_MAXIMIZED;

} else

#endif

{

window->flags &= ~SDL_WINDOW_MAXIMIZED;

}

if (style & WS_MINIMIZE) {

window->flags |= SDL_WINDOW_MINIMIZED;

} else

#endif

{

window->flags &= ~SDL_WINDOW_MINIMIZED;

}

}

if (GetFocus() == hwnd) {

window->flags |= SDL_WINDOW_INPUT_FOCUS;

if (window->flags & SDL_WINDOW_INPUT_GRABBED) {

RECT rect;

GetClientRect(hwnd, &rect);

ClientToScreen(hwnd, (LPPOINT) & rect);

ClientToScreen(hwnd, (LPPOINT) & rect + 1);

ClipCursor(&rect);

}

}

if (videodata->RegisterTouchWindow) {

videodata->RegisterTouchWindow(hwnd, (TWF_FINETOUCH|TWF_WANTPALM));

}

/* All done! */

window->driverdata = data;

return 0;

}

int

WIN_CreateWindow(_THIS, SDL_Window * window)

{

HWND hwnd;

RECT rect;

int x, y;

int w, h;

style |= GetWindowStyle(window);

/* Figure out what the window area will be */

rect.left = window->x;

rect.top = window->y;

rect.right = window->x + window->w;

rect.bottom = window->y + window->h;

x = rect.left;

y = rect.top;

w = (rect.right - rect.left);

h = (rect.bottom - rect.top);

hwnd =

CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,

SDL_Instance, NULL);

if (!hwnd) {

WIN_SetError("Couldn't create window");

return -1;

}

WIN_PumpEvents(_this);

DestroyWindow(hwnd);

return -1;

}

if (window->flags & SDL_WINDOW_OPENGL) {

if (WIN_GL_SetupWindow(_this, window) < 0) {

WIN_DestroyWindow(_this, window);

return -1;

}

}

#endif

return 0;

}

int

WIN_CreateWindowFrom(_THIS, SDL_Window * window, const void *data)

{

HWND hwnd = (HWND) data;

LPTSTR title;

int titleLen;

/* Query the title from the existing window */

titleLen = GetWindowTextLength(hwnd);

title = SDL_stack_alloc(TCHAR, titleLen + 1);

if (title) {

titleLen = GetWindowText(hwnd, title, titleLen);

} else {

titleLen = 0;

}

if (titleLen > 0) {

window->title = WIN_StringToUTF8(title);

}

if (title) {

SDL_stack_free(title);

}

return -1;

}

return 0;

}

void

WIN_SetWindowTitle(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

LPTSTR title;

if (window->title) {

title = WIN_UTF8ToString(window->title);

} else {

title = NULL;

}

SetWindowText(hwnd, title ? title : TEXT(""));

if (title) {

SDL_free(title);

}

}

void

WIN_SetWindowIcon(_THIS, SDL_Window * window, SDL_Surface * icon)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

HICON hicon = NULL;

BYTE *icon_bmp;

int icon_len;

SDL_RWops *dst;

SDL_Surface *surface;

/* Create temporary bitmap buffer */

icon_len = 40 + icon->h * icon->w * 4;

icon_bmp = SDL_stack_alloc(BYTE, icon_len);

dst = SDL_RWFromMem(icon_bmp, icon_len);

if (!dst) {

SDL_stack_free(icon_bmp);

return;

}

/* Write the BITMAPINFO header */

SDL_WriteLE32(dst, 40);

SDL_WriteLE32(dst, icon->w);

SDL_WriteLE32(dst, icon->h * 2);

SDL_WriteLE16(dst, 1);

SDL_WriteLE16(dst, 32);

SDL_WriteLE32(dst, BI_RGB);

SDL_WriteLE32(dst, icon->h * icon->w * 4);

SDL_WriteLE32(dst, 0);

SDL_WriteLE32(dst, 0);

SDL_WriteLE32(dst, 0);

SDL_WriteLE32(dst, 0);

/* Convert the icon to a 32-bit surface with alpha channel */

surface = SDL_ConvertSurfaceFormat(icon, SDL_PIXELFORMAT_ARGB8888, 0);

if (surface) {

/* Write the pixels upside down into the bitmap buffer */

int y = surface->h;

while (y--) {

Uint8 *src = (Uint8 *) surface->pixels + y * surface->pitch;

SDL_RWwrite(dst, src, surface->pitch, 1);

/* TODO: create the icon in WinCE (CreateIconFromResource isn't available) */

#ifndef _WIN32_WCE

SDL_RWclose(dst);

SDL_stack_free(icon_bmp);

/* Set the icon in the task manager (should we do this?) */

}

void

WIN_SetWindowPosition(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

RECT rect;

DWORD style;

HWND top;

/* Figure out what the window area will be */

if (window->flags & SDL_WINDOW_FULLSCREEN) {

top = HWND_TOPMOST;

} else {

top = HWND_NOTOPMOST;

}

style = GetWindowLong(hwnd, GWL_STYLE);

rect.left = 0;

rect.top = 0;

rect.right = window->w;

rect.bottom = window->h;

#ifdef _WIN32_WCE

menu = FALSE;

#else

menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);

#endif

AdjustWindowRectEx(&rect, style, menu, 0);

w = (rect.right - rect.left);

h = (rect.bottom - rect.top);

x = window->x + rect.left;

y = window->y + rect.top;

}

void

WIN_SetWindowSize(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

RECT rect;

DWORD style;

HWND top;

int w, h;

/* Figure out what the window area will be */

if (window->flags & SDL_WINDOW_FULLSCREEN) {

top = HWND_TOPMOST;

} else {

top = HWND_NOTOPMOST;

}

style = GetWindowLong(hwnd, GWL_STYLE);

rect.left = 0;

rect.top = 0;

rect.right = window->w;

rect.bottom = window->h;

#ifdef _WIN32_WCE

menu = FALSE;

#else

menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);

#endif

AdjustWindowRectEx(&rect, style, menu, 0);

w = (rect.right - rect.left);

h = (rect.bottom - rect.top);

}

#ifdef _WIN32_WCE

void WINCE_ShowWindow(_THIS, SDL_Window* window, int visible)

{

SDL_WindowData* windowdata = (SDL_WindowData*) window->driverdata;

SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;

if(visible) {

if(window->flags & SDL_WINDOW_FULLSCREEN) {

if(videodata->SHFullScreen)

videodata->SHFullScreen(windowdata->hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);

ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_HIDE);

}

ShowWindow(windowdata->hwnd, SW_SHOW);

SetForegroundWindow(windowdata->hwnd);

} else {

ShowWindow(windowdata->hwnd, SW_HIDE);

if(window->flags & SDL_WINDOW_FULLSCREEN) {

if(videodata->SHFullScreen)

videodata->SHFullScreen(windowdata->hwnd, SHFS_SHOWTASKBAR | SHFS_SHOWSTARTICON | SHFS_SHOWSIPBUTTON);

ShowWindow(FindWindow(TEXT("HHTaskBar"), NULL), SW_SHOW);

}

}

void

WIN_ShowWindow(_THIS, SDL_Window * window)

{

#ifdef _WIN32_WCE

WINCE_ShowWindow(_this, window, 1);

#else

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

ShowWindow(hwnd, SW_SHOW);

}

void

WIN_HideWindow(_THIS, SDL_Window * window)

{

#ifdef _WIN32_WCE

WINCE_ShowWindow(_this, window, 0);

#else

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

ShowWindow(hwnd, SW_HIDE);

}

void

WIN_RaiseWindow(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

HWND top;

if (window->flags & SDL_WINDOW_FULLSCREEN) {

top = HWND_TOPMOST;

} else {

top = HWND_NOTOPMOST;

}

SetWindowPos(hwnd, top, 0, 0, 0, 0, (SWP_NOMOVE | SWP_NOSIZE));

}

void

WIN_MaximizeWindow(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

#ifdef _WIN32_WCE

if((window->flags & SDL_WINDOW_FULLSCREEN) && videodata->SHFullScreen)

videodata->SHFullScreen(hwnd, SHFS_HIDETASKBAR | SHFS_HIDESTARTICON | SHFS_HIDESIPBUTTON);

ShowWindow(hwnd, SW_MAXIMIZE);

}

void

WIN_MinimizeWindow(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

ShowWindow(hwnd, SW_MINIMIZE);

#ifdef _WIN32_WCE

}

void

WIN_RestoreWindow(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

ShowWindow(hwnd, SW_RESTORE);

}

void

WIN_SetWindowFullscreen(_THIS, SDL_Window * window, SDL_VideoDisplay * display, SDL_bool fullscreen)

{

SDL_WindowData *data = (SDL_WindowData *) window->driverdata;

HWND hwnd = data->hwnd;

RECT rect;

SDL_Rect bounds;

DWORD style;

HWND top;

BOOL menu;

int x, y;

int w, h;

if (fullscreen) {

top = HWND_TOPMOST;

} else {

top = HWND_NOTOPMOST;

}

style = GetWindowLong(hwnd, GWL_STYLE);

style &= ~STYLE_MASK;

style |= GetWindowStyle(window);

WIN_GetDisplayBounds(_this, display, &bounds);

if (fullscreen) {

x = bounds.x;

y = bounds.y;

w = bounds.w;

h = bounds.h;

} else {

rect.left = 0;

rect.top = 0;

rect.right = window->windowed.w;

rect.bottom = window->windowed.h;

#ifdef _WIN32_WCE

menu = FALSE;

#else

menu = (style & WS_CHILDWINDOW) ? FALSE : (GetMenu(hwnd) != NULL);

#endif

AdjustWindowRectEx(&rect, style, menu, 0);

w = (rect.right - rect.left);

h = (rect.bottom - rect.top);

x = window->windowed.x + rect.left;

y = window->windowed.y + rect.top;

}

SetWindowLong(hwnd, GWL_STYLE, style);

SetWindowPos(hwnd, top, x, y, w, h, SWP_NOCOPYBITS);

}

int

WIN_SetWindowGammaRamp(_THIS, SDL_Window * window, const Uint16 * ramp)

{

#ifdef _WIN32_WCE

SDL_Unsupported();

return -1;

#else

SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);

SDL_DisplayData *data = (SDL_DisplayData *) display->driverdata;

HDC hdc;

BOOL succeeded = FALSE;

hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);

if (hdc) {

succeeded = SetDeviceGammaRamp(hdc, (LPVOID)ramp);

if (!succeeded) {

WIN_SetError("SetDeviceGammaRamp()");

}

DeleteDC(hdc);

}

return succeeded ? 0 : -1;

#endif

}

int

WIN_GetWindowGammaRamp(_THIS, SDL_Window * window, Uint16 * ramp)

{

#ifdef _WIN32_WCE

SDL_Unsupported();

return -1;

#else

SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window);

SDL_DisplayData *data = (SDL_DisplayData *) display->driverdata;

HDC hdc;

BOOL succeeded = FALSE;

hdc = CreateDC(data->DeviceName, NULL, NULL, NULL);

if (hdc) {

succeeded = GetDeviceGammaRamp(hdc, (LPVOID)ramp);

if (!succeeded) {

WIN_SetError("GetDeviceGammaRamp()");

}

DeleteDC(hdc);

}

return succeeded ? 0 : -1;

#endif

}

void

WIN_SetWindowGrab(_THIS, SDL_Window * window)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

if ((window->flags & SDL_WINDOW_INPUT_GRABBED) &&

(window->flags & SDL_WINDOW_INPUT_FOCUS)) {

RECT rect;

GetClientRect(hwnd, &rect);

ClientToScreen(hwnd, (LPPOINT) & rect);

ClientToScreen(hwnd, (LPPOINT) & rect + 1);

ClipCursor(&rect);

} else {

ClipCursor(NULL);

}

}

void

WIN_DestroyWindow(_THIS, SDL_Window * window)

{

SDL_WindowData *data = (SDL_WindowData *) window->driverdata;

if (data) {

#ifdef _WIN32_WCE

WINCE_ShowWindow(_this, window, 0);

#endif

if (data->created) {

DestroyWindow(data->hwnd);

}

SDL_free(data);

}

}

SDL_bool

WIN_GetWindowWMInfo(_THIS, SDL_Window * window, SDL_SysWMinfo * info)

{

HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

if (info->version.major <= SDL_MAJOR_VERSION) {

return SDL_TRUE;

} else {

SDL_SetError("Application not compiled with SDL %d.%d\n",

SDL_MAJOR_VERSION, SDL_MINOR_VERSION);

return SDL_FALSE;

}

}

/*

* Creates a HelperWindow used for DirectInput events.

*/

int

SDL_HelperWindowCreate(void)

{

HINSTANCE hInstance = GetModuleHandle(NULL);

WNDCLASS wce;

/* Make sure window isn't created twice. */

if (SDL_HelperWindow != NULL) {

return 0;

}

wce.lpszClassName = (LPCWSTR) SDL_HelperWindowClassName;

wce.hInstance = hInstance;

/* Register the class. */

return -1;

}

#ifndef _WIN32_WCE

/* WinCE doesn't have HWND_MESSAGE */

hWndParent = HWND_MESSAGE;

#endif

SDL_HelperWindow = CreateWindowEx(0, SDL_HelperWindowClassName,

SDL_HelperWindowName,

return -1;

}

return 0;

}

/*

* Destroys the HelperWindow previously created with SDL_HelperWindowCreate.

*/

void

SDL_HelperWindowDestroy(void)

{

if (SDL_HelperWindow != NULL) {

if (DestroyWindow(SDL_HelperWindow) == 0) {

SDL_HelperWindow = NULL;

}

/* Unregister the class. */

if (SDL_HelperWindowClass != 0) {

if ((UnregisterClass(SDL_HelperWindowClassName, hInstance)) == 0) {

SDL_HelperWindowClass = 0;

}

}