[sdl_omap.git] / src / video / wincommon / SDL_syswm.c

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2009 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

    Sam Lantinga
    slouken@libsdl.org
*/
#include "SDL_config.h"

#define WIN32_LEAN_AND_MEAN
#include <windows.h>

#include "SDL_version.h"
#include "SDL_video.h"
#include "SDL_loadso.h"
#include "SDL_syswm.h"
#include "../SDL_pixels_c.h"
#include "../SDL_cursor_c.h"
#include "SDL_syswm_c.h"
#include "SDL_wingl_c.h"


#ifdef _WIN32_WCE
#define DISABLE_ICON_SUPPORT
#endif

/* The screen icon -- needs to be freed on SDL_VideoQuit() */
HICON   screen_icn = NULL;

/* Win32 icon mask semantics are different from those of SDL:
     SDL applies the mask to the icon and copies result to desktop.
     Win32 applies the mask to the desktop and XORs the icon on.
   This means that the SDL mask needs to be applied to the icon and
   then inverted and passed to Win32.
*/
void WIN_SetWMIcon(_THIS, SDL_Surface *icon, Uint8 *mask)
{
#ifdef DISABLE_ICON_SUPPORT
	return;
#else
	SDL_Palette *pal_256;
	SDL_Surface *icon_256;
	Uint8 *pdata, *pwin32;
	Uint8 *mdata, *mwin32, m = 0;
	int icon_len;
	int icon_plen;
	int icon_mlen;
	int icon_pitch;
	int mask_pitch;
	SDL_Rect bounds;
	int i, skip;
	int row, col;
	struct /* quasi-BMP format */ Win32Icon {
		Uint32 biSize;
		Sint32 biWidth;
		Sint32 biHeight;
		Uint16 biPlanes;
		Uint16 biBitCount;
		Uint32 biCompression;
		Uint32 biSizeImage;
		Sint32 biXPelsPerMeter;
		Sint32 biYPelsPerMeter;
		Uint32 biClrUsed;
		Uint32 biClrImportant;
		struct /* RGBQUAD -- note it's BGR ordered */ {
			Uint8 rgbBlue;
			Uint8 rgbGreen;
			Uint8 rgbRed;
			Uint8 rgbReserved;
		} biColors[256];
		/* Pixels:
		Uint8 pixels[]
		*/
		/* Mask:
		Uint8 mask[]
		*/
	} *icon_win32;
	
	/* Allocate the win32 bmp icon and set everything to zero */
	icon_pitch = ((icon->w+3)&~3);
	mask_pitch = ((icon->w+7)/8);
	icon_plen = icon->h*icon_pitch;
	icon_mlen = icon->h*mask_pitch;
	icon_len = sizeof(*icon_win32)+icon_plen+icon_mlen;
	icon_win32 = (struct Win32Icon *)SDL_stack_alloc(Uint8, icon_len);
	if ( icon_win32 == NULL ) {
		return;
	}
	SDL_memset(icon_win32, 0, icon_len);

	/* Set the basic BMP parameters */
	icon_win32->biSize = sizeof(*icon_win32)-sizeof(icon_win32->biColors);
	icon_win32->biWidth = icon->w;
	icon_win32->biHeight = icon->h*2;
	icon_win32->biPlanes = 1;
	icon_win32->biBitCount = 8;
	icon_win32->biSizeImage = icon_plen+icon_mlen;

	/* Allocate a standard 256 color icon surface */
	icon_256 = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
					 icon_win32->biBitCount, 0, 0, 0, 0);
	if ( icon_256 == NULL ) {
		SDL_stack_free(icon_win32);
		return;
	}
	pal_256 = icon_256->format->palette;
	if (icon->format->palette && 
		(icon->format->BitsPerPixel == icon_256->format->BitsPerPixel)){
		Uint8 black;
		SDL_memcpy(pal_256->colors, icon->format->palette->colors,
					pal_256->ncolors*sizeof(SDL_Color));
		/* Make sure that 0 is black! */
		black = SDL_FindColor(pal_256, 0x00, 0x00, 0x00);
		pal_256->colors[black] = pal_256->colors[0];
		pal_256->colors[0].r = 0x00;
		pal_256->colors[0].g = 0x00;
		pal_256->colors[0].b = 0x00;
	} else {
		SDL_DitherColors(pal_256->colors,
					icon_256->format->BitsPerPixel);
	}

	/* Now copy color data to the icon BMP */
	for ( i=0; i<(1<<icon_win32->biBitCount); ++i ) {
		icon_win32->biColors[i].rgbRed = pal_256->colors[i].r;
		icon_win32->biColors[i].rgbGreen = pal_256->colors[i].g;
		icon_win32->biColors[i].rgbBlue = pal_256->colors[i].b;
	}

	/* Convert icon to a standard surface format.  This may not always
	   be necessary, as Windows supports a variety of BMP formats, but
	   it greatly simplifies our code.
	*/ 
    bounds.x = 0;
    bounds.y = 0;
    bounds.w = icon->w;
    bounds.h = icon->h;
    if ( SDL_LowerBlit(icon, &bounds, icon_256, &bounds) < 0 ) {
	    SDL_stack_free(icon_win32);
		SDL_FreeSurface(icon_256);
        return;
	}

	/* Copy pixels upside-down to icon BMP, masked with the icon mask */
	if ( SDL_MUSTLOCK(icon_256) || (icon_256->pitch != icon_pitch) ) {
		SDL_stack_free(icon_win32);
		SDL_FreeSurface(icon_256);
		SDL_SetError("Warning: Unexpected icon_256 characteristics");
		return;
	}
	pdata = (Uint8 *)icon_256->pixels;
	mdata = mask;
	pwin32 = (Uint8 *)icon_win32+sizeof(*icon_win32)+icon_plen-icon_pitch;
	skip = icon_pitch - icon->w;
	for ( row=0; row<icon->h; ++row ) {
		for ( col=0; col<icon->w; ++col ) {
			if ( (col%8) == 0 ) {
				m = *mdata++;
			}
			if ( (m&0x80) != 0x00 ) {
				*pwin32 = *pdata;
			}
			m <<= 1;
			++pdata;
			++pwin32;
		}
		pdata  += skip;
		pwin32 += skip;
		pwin32 -= 2*icon_pitch;
	}
	SDL_FreeSurface(icon_256);

	/* Copy mask inverted and upside-down to icon BMP */
	mdata = mask;
	mwin32 = (Uint8 *)icon_win32
			+sizeof(*icon_win32)+icon_plen+icon_mlen-mask_pitch;
	for ( row=0; row<icon->h; ++row ) {
		for ( col=0; col<mask_pitch; ++col ) {
			*mwin32++ = ~*mdata++;
		}
		mwin32 -= 2*mask_pitch;
	}

	/* Finally, create the icon handle and set the window icon */
	screen_icn = CreateIconFromResourceEx((Uint8 *)icon_win32, icon_len,
			TRUE, 0x00030000, icon->w, icon->h, LR_DEFAULTCOLOR);
	if ( screen_icn == NULL ) {
		SDL_SetError("Couldn't create Win32 icon handle");
	} else {
		SetClassLongPtr(SDL_Window, GCLP_HICON, (LONG_PTR)screen_icn);
	}
	SDL_stack_free(icon_win32);
#endif /* DISABLE_ICON_SUPPORT */
}

typedef BOOL (WINAPI *PtrSetWindowTextW)(HWND hWnd, LPCWSTR lpString);

void WIN_SetWMCaption(_THIS, const char *title, const char *icon)
{
#ifdef _WIN32_WCE
	/* WinCE uses the UNICODE version */
	LPWSTR lpszW = SDL_iconv_utf8_ucs2((char *)title);
	SetWindowText(SDL_Window, lpszW);
	SDL_free(lpszW);
#else
	Uint16 *lpsz = SDL_iconv_utf8_ucs2(title);
	size_t len = WideCharToMultiByte(CP_ACP, 0, lpsz, -1, NULL, 0, NULL, NULL);
	char *cvt = SDL_stack_alloc(char, len + 1);
	WideCharToMultiByte(CP_ACP, 0, lpsz, -1, cvt, len, NULL, NULL);
	SetWindowText(SDL_Window, cvt);
	SDL_stack_free(cvt);
	SDL_free(lpsz);
#endif
}

int WIN_IconifyWindow(_THIS)
{
	ShowWindow(SDL_Window, SW_MINIMIZE);
	return(1);
}

SDL_GrabMode WIN_GrabInput(_THIS, SDL_GrabMode mode)
{
	if ( mode == SDL_GRAB_OFF ) {
		ClipCursor(NULL);
		if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
		/*	RJR: March 28, 2000
			must be leaving relative mode, move mouse from
			center of window to where it belongs ... */
			POINT pt;
			int x, y;
			SDL_GetMouseState(&x,&y);
			pt.x = x;
			pt.y = y;
			ClientToScreen(SDL_Window, &pt);
			SetCursorPos(pt.x,pt.y);
		}
#ifdef _WIN32_WCE
		AllKeys(0);
#endif
	} else {
		ClipCursor(&SDL_bounds);
		if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
		/*	RJR: March 28, 2000
			must be entering relative mode, get ready by
			moving mouse to	center of window ... */
			POINT pt;
			pt.x = (SDL_VideoSurface->w/2);
			pt.y = (SDL_VideoSurface->h/2);
			ClientToScreen(SDL_Window, &pt);
			SetCursorPos(pt.x, pt.y);
		}
#ifdef _WIN32_WCE
		AllKeys(1);
#endif
	}
	return(mode);
}

/* If 'info' is the right version, this function fills it and returns 1.
   Otherwise, in case of a version mismatch, it returns -1.
*/
int WIN_GetWMInfo(_THIS, SDL_SysWMinfo *info)
{
	if ( info->version.major <= SDL_MAJOR_VERSION ) {
		info->window = SDL_Window;
		if ( SDL_VERSIONNUM(info->version.major,
		                    info->version.minor,
		                    info->version.patch) >=
		     SDL_VERSIONNUM(1, 2, 5) ) {
#if SDL_VIDEO_OPENGL
			info->hglrc = GL_hrc;
#else
			info->hglrc = NULL;
#endif
		}
		return(1);
	} else {
		SDL_SetError("Application not compiled with SDL %d.%d\n",
					SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
		return(-1);
	}
}
Commit	Line	Data
e14743d1	1	/*
	2	SDL - Simple DirectMedia Layer
	3	Copyright (C) 1997-2009 Sam Lantinga
	4
	5	This library is free software; you can redistribute it and/or
	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 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	Lesser General Public License for more details.
	14
	15	You should have received a copy of the GNU Lesser General Public
	16	License along with this library; if not, write to the Free Software
	17	Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18
	19	Sam Lantinga
	20	slouken@libsdl.org
	21	*/
	22	#include "SDL_config.h"
	23
	24	#define WIN32_LEAN_AND_MEAN
	25	#include <windows.h>
	26
	27	#include "SDL_version.h"
	28	#include "SDL_video.h"
	29	#include "SDL_loadso.h"
	30	#include "SDL_syswm.h"
	31	#include "../SDL_pixels_c.h"
	32	#include "../SDL_cursor_c.h"
	33	#include "SDL_syswm_c.h"
	34	#include "SDL_wingl_c.h"
	35
	36
	37	#ifdef _WIN32_WCE
	38	#define DISABLE_ICON_SUPPORT
	39	#endif
	40
	41	/* The screen icon -- needs to be freed on SDL_VideoQuit() */
	42	HICON screen_icn = NULL;
	43
	44	/* Win32 icon mask semantics are different from those of SDL:
	45	SDL applies the mask to the icon and copies result to desktop.
	46	Win32 applies the mask to the desktop and XORs the icon on.
	47	This means that the SDL mask needs to be applied to the icon and
	48	then inverted and passed to Win32.
	49	*/
	50	void WIN_SetWMIcon(_THIS, SDL_Surface icon, Uint8 mask)
	51	{
	52	#ifdef DISABLE_ICON_SUPPORT
	53	return;
	54	#else
	55	SDL_Palette *pal_256;
	56	SDL_Surface *icon_256;
	57	Uint8 pdata, pwin32;
	58	Uint8 mdata, mwin32, m = 0;
	59	int icon_len;
	60	int icon_plen;
	61	int icon_mlen;
	62	int icon_pitch;
	63	int mask_pitch;
	64	SDL_Rect bounds;
65	int i, skip;
66	int row, col;
67	struct /* quasi-BMP format */ Win32Icon {
68	Uint32 biSize;
69	Sint32 biWidth;
70	Sint32 biHeight;
71	Uint16 biPlanes;
72	Uint16 biBitCount;
73	Uint32 biCompression;
74	Uint32 biSizeImage;
75	Sint32 biXPelsPerMeter;
76	Sint32 biYPelsPerMeter;
77	Uint32 biClrUsed;
78	Uint32 biClrImportant;
79	struct /* RGBQUAD -- note it's BGR ordered */ {
80	Uint8 rgbBlue;
81	Uint8 rgbGreen;
82	Uint8 rgbRed;
83	Uint8 rgbReserved;
84	} biColors[256];
85	/* Pixels:
86	Uint8 pixels[]
87	*/
88	/* Mask:
89	Uint8 mask[]
90	*/
91	} *icon_win32;
92
93	/* Allocate the win32 bmp icon and set everything to zero */
94	icon_pitch = ((icon->w+3)&~3);
95	mask_pitch = ((icon->w+7)/8);
96	icon_plen = icon->h*icon_pitch;
97	icon_mlen = icon->h*mask_pitch;
98	icon_len = sizeof(*icon_win32)+icon_plen+icon_mlen;
99	icon_win32 = (struct Win32Icon *)SDL_stack_alloc(Uint8, icon_len);
100	if ( icon_win32 == NULL ) {
101	return;
102	}
103	SDL_memset(icon_win32, 0, icon_len);
104
105	/* Set the basic BMP parameters */
106	icon_win32->biSize = sizeof(*icon_win32)-sizeof(icon_win32->biColors);
107	icon_win32->biWidth = icon->w;
108	icon_win32->biHeight = icon->h*2;
109	icon_win32->biPlanes = 1;
110	icon_win32->biBitCount = 8;
111	icon_win32->biSizeImage = icon_plen+icon_mlen;
112
113	/* Allocate a standard 256 color icon surface */
114	icon_256 = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
115	icon_win32->biBitCount, 0, 0, 0, 0);
116	if ( icon_256 == NULL ) {
117	SDL_stack_free(icon_win32);
118	return;
119	}
120	pal_256 = icon_256->format->palette;
121	if (icon->format->palette &&
122	(icon->format->BitsPerPixel == icon_256->format->BitsPerPixel)){
123	Uint8 black;
124	SDL_memcpy(pal_256->colors, icon->format->palette->colors,
125	pal_256->ncolors*sizeof(SDL_Color));
126	/* Make sure that 0 is black! */
127	black = SDL_FindColor(pal_256, 0x00, 0x00, 0x00);
128	pal_256->colors[black] = pal_256->colors[0];
129	pal_256->colors[0].r = 0x00;
130	pal_256->colors[0].g = 0x00;
131	pal_256->colors[0].b = 0x00;
132	} else {
133	SDL_DitherColors(pal_256->colors,
134	icon_256->format->BitsPerPixel);
135	}
136
137	/* Now copy color data to the icon BMP */
138	for ( i=0; i<(1<<icon_win32->biBitCount); ++i ) {
139	icon_win32->biColors[i].rgbRed = pal_256->colors[i].r;
140	icon_win32->biColors[i].rgbGreen = pal_256->colors[i].g;
141	icon_win32->biColors[i].rgbBlue = pal_256->colors[i].b;
142	}
143
144	/* Convert icon to a standard surface format. This may not always
145	be necessary, as Windows supports a variety of BMP formats, but
146	it greatly simplifies our code.
147	*/
148	bounds.x = 0;
149	bounds.y = 0;
150	bounds.w = icon->w;
151	bounds.h = icon->h;
152	if ( SDL_LowerBlit(icon, &bounds, icon_256, &bounds) < 0 ) {
153	SDL_stack_free(icon_win32);
154	SDL_FreeSurface(icon_256);
155	return;
156	}
157
158	/* Copy pixels upside-down to icon BMP, masked with the icon mask */
159	if ( SDL_MUSTLOCK(icon_256) \|\| (icon_256->pitch != icon_pitch) ) {
160	SDL_stack_free(icon_win32);
161	SDL_FreeSurface(icon_256);
162	SDL_SetError("Warning: Unexpected icon_256 characteristics");
163	return;
164	}
165	pdata = (Uint8 *)icon_256->pixels;
166	mdata = mask;
167	pwin32 = (Uint8 )icon_win32+sizeof(icon_win32)+icon_plen-icon_pitch;
168	skip = icon_pitch - icon->w;
169	for ( row=0; row<icon->h; ++row ) {
170	for ( col=0; col<icon->w; ++col ) {
171	if ( (col%8) == 0 ) {
172	m = *mdata++;
173	}
174	if ( (m&0x80) != 0x00 ) {
175	pwin32 = pdata;
176	}
177	m <<= 1;
178	++pdata;
179	++pwin32;
180	}
181	pdata += skip;
182	pwin32 += skip;
183	pwin32 -= 2*icon_pitch;
184	}
185	SDL_FreeSurface(icon_256);
186
187	/* Copy mask inverted and upside-down to icon BMP */
188	mdata = mask;
189	mwin32 = (Uint8 *)icon_win32
190	+sizeof(*icon_win32)+icon_plen+icon_mlen-mask_pitch;
191	for ( row=0; row<icon->h; ++row ) {
192	for ( col=0; col<mask_pitch; ++col ) {
193	mwin32++ = ~mdata++;
194	}
195	mwin32 -= 2*mask_pitch;
196	}
197
198	/* Finally, create the icon handle and set the window icon */
199	screen_icn = CreateIconFromResourceEx((Uint8 *)icon_win32, icon_len,
200	TRUE, 0x00030000, icon->w, icon->h, LR_DEFAULTCOLOR);
201	if ( screen_icn == NULL ) {
202	SDL_SetError("Couldn't create Win32 icon handle");
203	} else {
204	SetClassLongPtr(SDL_Window, GCLP_HICON, (LONG_PTR)screen_icn);
205	}
206	SDL_stack_free(icon_win32);
207	#endif /* DISABLE_ICON_SUPPORT */
208	}
209
210	typedef BOOL (WINAPI *PtrSetWindowTextW)(HWND hWnd, LPCWSTR lpString);
211
212	void WIN_SetWMCaption(_THIS, const char title, const char icon)
213	{
214	#ifdef _WIN32_WCE
215	/* WinCE uses the UNICODE version */
216	LPWSTR lpszW = SDL_iconv_utf8_ucs2((char *)title);
217	SetWindowText(SDL_Window, lpszW);
218	SDL_free(lpszW);
219	#else
220	Uint16 *lpsz = SDL_iconv_utf8_ucs2(title);
221	size_t len = WideCharToMultiByte(CP_ACP, 0, lpsz, -1, NULL, 0, NULL, NULL);
222	char *cvt = SDL_stack_alloc(char, len + 1);
223	WideCharToMultiByte(CP_ACP, 0, lpsz, -1, cvt, len, NULL, NULL);
224	SetWindowText(SDL_Window, cvt);
225	SDL_stack_free(cvt);
226	SDL_free(lpsz);
227	#endif
228	}
229
230	int WIN_IconifyWindow(_THIS)
231	{
232	ShowWindow(SDL_Window, SW_MINIMIZE);
233	return(1);
234	}
235
236	SDL_GrabMode WIN_GrabInput(_THIS, SDL_GrabMode mode)
237	{
238	if ( mode == SDL_GRAB_OFF ) {
239	ClipCursor(NULL);
240	if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
241	/* RJR: March 28, 2000
242	must be leaving relative mode, move mouse from
243	center of window to where it belongs ... */
244	POINT pt;
245	int x, y;
246	SDL_GetMouseState(&x,&y);
247	pt.x = x;
248	pt.y = y;
249	ClientToScreen(SDL_Window, &pt);
250	SetCursorPos(pt.x,pt.y);
251	}
252	#ifdef _WIN32_WCE
253	AllKeys(0);
254	#endif
255	} else {
256	ClipCursor(&SDL_bounds);
257	if ( !(SDL_cursorstate & CURSOR_VISIBLE) ) {
258	/* RJR: March 28, 2000
259	must be entering relative mode, get ready by
260	moving mouse to center of window ... */
261	POINT pt;
262	pt.x = (SDL_VideoSurface->w/2);
263	pt.y = (SDL_VideoSurface->h/2);
264	ClientToScreen(SDL_Window, &pt);
265	SetCursorPos(pt.x, pt.y);
266	}
267	#ifdef _WIN32_WCE
268	AllKeys(1);
269	#endif
270	}
271	return(mode);
272	}
273
274	/* If 'info' is the right version, this function fills it and returns 1.
275	Otherwise, in case of a version mismatch, it returns -1.
276	*/
277	int WIN_GetWMInfo(_THIS, SDL_SysWMinfo *info)
278	{
279	if ( info->version.major <= SDL_MAJOR_VERSION ) {
280	info->window = SDL_Window;
281	if ( SDL_VERSIONNUM(info->version.major,
282	info->version.minor,
283	info->version.patch) >=
284	SDL_VERSIONNUM(1, 2, 5) ) {
285	#if SDL_VIDEO_OPENGL
286	info->hglrc = GL_hrc;
287	#else
288	info->hglrc = NULL;
289	#endif
290	}
291	return(1);
292	} else {
293	SDL_SetError("Application not compiled with SDL %d.%d\n",
294	SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
295	return(-1);
296	}
297	}