[sdl_omap.git] / src / video / wincommon / SDL_sysmouse.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_mouse.h"
#include "../../events/SDL_events_c.h"
#include "../SDL_cursor_c.h"
#include "SDL_sysmouse_c.h"
#include "SDL_lowvideo.h"

#ifdef _WIN32_WCE
#define USE_STATIC_CURSOR
#endif

HCURSOR	SDL_hcursor = NULL;		/* Exported for SDL_eventloop.c */

/* The implementation dependent data for the window manager cursor */
/* For some reason when creating a windows cursor, the ands and xors memory
   is not copied, so we need to keep track of it and free it when we are done
   with the cursor.  If we free the memory prematurely, the app crashes. :-}
*/
struct WMcursor {
	HCURSOR curs;
#ifndef USE_STATIC_CURSOR
	Uint8 *ands;
	Uint8 *xors;
#endif
};

/* Convert bits to padded bytes */
#define PAD_BITS(bits)	((bits+7)/8)

#ifdef CURSOR_DEBUG
static void PrintBITMAP(FILE *out, char *bits, int w, int h)
{
	int i;
	unsigned char ch;

	while ( h-- > 0 ) {
		for ( i=0; i<w; ++i ) {
			if ( (i%8) == 0 )
				ch = *bits++;
			if ( ch&0x80 )
				fprintf(out, "X");
			else
				fprintf(out, " ");
			ch <<= 1;
		}
		fprintf(out, "\n");
	}
}
#endif

#ifndef USE_STATIC_CURSOR
/* Local functions to convert the SDL cursor mask into Windows format */
static void memnot(Uint8 *dst, Uint8 *src, int len)
{
	while ( len-- > 0 )
		*dst++ = ~*src++;
}
static void memxor(Uint8 *dst, Uint8 *src1, Uint8 *src2, int len)
{
	while ( len-- > 0 )
		*dst++ = (*src1++)^(*src2++);
}
#endif /* !USE_STATIC_CURSOR */

void WIN_FreeWMCursor(_THIS, WMcursor *cursor)
{
#ifndef USE_STATIC_CURSOR
	if ( cursor->curs == GetCursor() )
		SetCursor(NULL);
	if ( cursor->curs != NULL )
		DestroyCursor(cursor->curs);
	if ( cursor->ands != NULL )
		SDL_free(cursor->ands);
	if ( cursor->xors != NULL )
		SDL_free(cursor->xors);
#endif /* !USE_STATIC_CURSOR */
	SDL_free(cursor);
}

WMcursor *WIN_CreateWMCursor(_THIS,
		Uint8 *data, Uint8 *mask, int w, int h, int hot_x, int hot_y)
{
#ifdef USE_STATIC_CURSOR
	WMcursor *cursor;

	/* Allocate the cursor */
	cursor = (WMcursor *)SDL_malloc(sizeof(*cursor));
	if ( cursor ) {
		cursor->curs = LoadCursor(NULL, IDC_ARROW);
	}
	return(cursor);
#else
	WMcursor *cursor;
	int allowed_x;
	int allowed_y;
	int run, pad, i;
	Uint8 *aptr, *xptr;

	/* Check to make sure the cursor size is okay */
	allowed_x = GetSystemMetrics(SM_CXCURSOR);
	allowed_y = GetSystemMetrics(SM_CYCURSOR);
	if ( (w > allowed_x) || (h > allowed_y) ) {
		SDL_SetError("Only cursors of dimension (%dx%d) are allowed",
							allowed_x, allowed_y);
		return(NULL);
	}

	/* Allocate the cursor */
	cursor = (WMcursor *)SDL_malloc(sizeof(*cursor));
	if ( cursor == NULL ) {
		SDL_SetError("Out of memory");
		return(NULL);
	}
	cursor->curs = NULL;
	cursor->ands = NULL;
	cursor->xors = NULL;

	/* Pad out to the normal cursor size */
	run = PAD_BITS(w);
	pad = PAD_BITS(allowed_x)-run;
	aptr = cursor->ands = (Uint8 *)SDL_malloc((run+pad)*allowed_y);
	xptr = cursor->xors = (Uint8 *)SDL_malloc((run+pad)*allowed_y);
	if ( (aptr == NULL) || (xptr == NULL) ) {
		WIN_FreeWMCursor(NULL, cursor);
		SDL_OutOfMemory();
		return(NULL);
	}
	for ( i=0; i<h; ++i ) {
		memxor(xptr, data, mask, run);
		xptr += run;
		data += run;
		memnot(aptr, mask, run);
		mask += run;
		aptr += run;
		SDL_memset(xptr,  0, pad);
		xptr += pad;
		SDL_memset(aptr, ~0, pad);
		aptr += pad;
	}
	pad += run;
	for ( ; i<allowed_y; ++i ) {
		SDL_memset(xptr,  0, pad);
		xptr += pad;
		SDL_memset(aptr, ~0, pad);
		aptr += pad;
	}

	/* Create the cursor */
	cursor->curs = CreateCursor(
			(HINSTANCE)GetWindowLongPtr(SDL_Window, GWLP_HINSTANCE),
					hot_x, hot_y, allowed_x, allowed_y, 
						cursor->ands, cursor->xors);
	if ( cursor->curs == NULL ) {
		WIN_FreeWMCursor(NULL, cursor);
		SDL_SetError("Windows couldn't create the requested cursor");
		return(NULL);
	}
	return(cursor);
#endif /* USE_STATIC_CURSOR */
}

int WIN_ShowWMCursor(_THIS, WMcursor *cursor)
{
	POINT mouse_pos;

	if ( !this->screen ) {
		return(0);
	}

	/* Set the window cursor to our cursor, if applicable */
	if ( cursor != NULL ) {
		SDL_hcursor = cursor->curs;
	} else {
		SDL_hcursor = NULL;
	}
	GetCursorPos(&mouse_pos);
	if ( PtInRect(&SDL_bounds, mouse_pos) ) {
		SetCursor(SDL_hcursor);
	}
	return(1);
}

void WIN_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
{
	if ( mouse_relative) {
		/*	RJR: March 28, 2000
			leave physical cursor at center of screen if
			mouse hidden and grabbed */
		SDL_PrivateMouseMotion(0, 0, x, y);
	} else {
		POINT pt;

		/* With DirectInput the position doesn't follow
		 * the cursor, so it is set manually */
		if ( DINPUT() ) {
			SDL_PrivateMouseMotion(0, 0, x, y);
		}

		pt.x = x;
		pt.y = y;
		ClientToScreen(SDL_Window, &pt);
		SetCursorPos(pt.x, pt.y);
	}
}

/* Update the current mouse state and position */
void WIN_UpdateMouse(_THIS)
{
	POINT pt;

	/* Always unset SDL_APPMOUSEFOCUS to give the WM_MOUSEMOVE event
	 * handler a chance to install a TRACKMOUSEEVENT */
	SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);

	GetCursorPos(&pt);
	ScreenToClient(SDL_Window, &pt);
	SDL_PrivateMouseMotion(0,0, (Sint16)pt.x, (Sint16)pt.y);
}

/* Check to see if we need to enter or leave mouse relative mode */
void WIN_CheckMouseMode(_THIS)
{
#ifndef _WIN32_WCE 
        /* If the mouse is hidden and input is grabbed, we use relative mode */
        if ( !(SDL_cursorstate & CURSOR_VISIBLE) &&
             (this->input_grab != SDL_GRAB_OFF) ) {
                mouse_relative = 1;
        } else {
                mouse_relative = 0;
        }
#else
		mouse_relative =  0; 
#endif
}
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_mouse.h"
	28	#include "../../events/SDL_events_c.h"
	29	#include "../SDL_cursor_c.h"
	30	#include "SDL_sysmouse_c.h"
	31	#include "SDL_lowvideo.h"
	32
	33	#ifdef _WIN32_WCE
	34	#define USE_STATIC_CURSOR
	35	#endif
	36
	37	HCURSOR SDL_hcursor = NULL; /* Exported for SDL_eventloop.c */
	38
	39	/* The implementation dependent data for the window manager cursor */
	40	/* For some reason when creating a windows cursor, the ands and xors memory
	41	is not copied, so we need to keep track of it and free it when we are done
	42	with the cursor. If we free the memory prematurely, the app crashes. :-}
	43	*/
	44	struct WMcursor {
	45	HCURSOR curs;
	46	#ifndef USE_STATIC_CURSOR
	47	Uint8 *ands;
	48	Uint8 *xors;
	49	#endif
	50	};
	51
	52	/* Convert bits to padded bytes */
	53	#define PAD_BITS(bits) ((bits+7)/8)
	54
	55	#ifdef CURSOR_DEBUG
	56	static void PrintBITMAP(FILE out, char bits, int w, int h)
	57	{
	58	int i;
	59	unsigned char ch;
	60
	61	while ( h-- > 0 ) {
	62	for ( i=0; i<w; ++i ) {
	63	if ( (i%8) == 0 )
	64	ch = *bits++;
65	if ( ch&0x80 )
66	fprintf(out, "X");
67	else
68	fprintf(out, " ");
69	ch <<= 1;
70	}
71	fprintf(out, "\n");
72	}
73	}
74	#endif
75
76	#ifndef USE_STATIC_CURSOR
77	/* Local functions to convert the SDL cursor mask into Windows format */
78	static void memnot(Uint8 dst, Uint8 src, int len)
79	{
80	while ( len-- > 0 )
81	dst++ = ~src++;
82	}
83	static void memxor(Uint8 dst, Uint8 src1, Uint8 *src2, int len)
84	{
85	while ( len-- > 0 )
86	dst++ = (src1++)^(*src2++);
87	}
88	#endif /* !USE_STATIC_CURSOR */
89
90	void WIN_FreeWMCursor(_THIS, WMcursor *cursor)
91	{
92	#ifndef USE_STATIC_CURSOR
93	if ( cursor->curs == GetCursor() )
94	SetCursor(NULL);
95	if ( cursor->curs != NULL )
96	DestroyCursor(cursor->curs);
97	if ( cursor->ands != NULL )
98	SDL_free(cursor->ands);
99	if ( cursor->xors != NULL )
100	SDL_free(cursor->xors);
101	#endif /* !USE_STATIC_CURSOR */
102	SDL_free(cursor);
103	}
104
105	WMcursor *WIN_CreateWMCursor(_THIS,
106	Uint8 data, Uint8 mask, int w, int h, int hot_x, int hot_y)
107	{
108	#ifdef USE_STATIC_CURSOR
109	WMcursor *cursor;
110
111	/* Allocate the cursor */
112	cursor = (WMcursor )SDL_malloc(sizeof(cursor));
113	if ( cursor ) {
114	cursor->curs = LoadCursor(NULL, IDC_ARROW);
115	}
116	return(cursor);
117	#else
118	WMcursor *cursor;
119	int allowed_x;
120	int allowed_y;
121	int run, pad, i;
122	Uint8 aptr, xptr;
123
124	/* Check to make sure the cursor size is okay */
125	allowed_x = GetSystemMetrics(SM_CXCURSOR);
126	allowed_y = GetSystemMetrics(SM_CYCURSOR);
127	if ( (w > allowed_x) \|\| (h > allowed_y) ) {
128	SDL_SetError("Only cursors of dimension (%dx%d) are allowed",
129	allowed_x, allowed_y);
130	return(NULL);
131	}
132
133	/* Allocate the cursor */
134	cursor = (WMcursor )SDL_malloc(sizeof(cursor));
135	if ( cursor == NULL ) {
136	SDL_SetError("Out of memory");
137	return(NULL);
138	}
139	cursor->curs = NULL;
140	cursor->ands = NULL;
141	cursor->xors = NULL;
142
143	/* Pad out to the normal cursor size */
144	run = PAD_BITS(w);
145	pad = PAD_BITS(allowed_x)-run;
146	aptr = cursor->ands = (Uint8 )SDL_malloc((run+pad)allowed_y);
147	xptr = cursor->xors = (Uint8 )SDL_malloc((run+pad)allowed_y);
148	if ( (aptr == NULL) \|\| (xptr == NULL) ) {
149	WIN_FreeWMCursor(NULL, cursor);
150	SDL_OutOfMemory();
151	return(NULL);
152	}
153	for ( i=0; i<h; ++i ) {
154	memxor(xptr, data, mask, run);
155	xptr += run;
156	data += run;
157	memnot(aptr, mask, run);
158	mask += run;
159	aptr += run;
160	SDL_memset(xptr, 0, pad);
161	xptr += pad;
162	SDL_memset(aptr, ~0, pad);
163	aptr += pad;
164	}
165	pad += run;
166	for ( ; i<allowed_y; ++i ) {
167	SDL_memset(xptr, 0, pad);
168	xptr += pad;
169	SDL_memset(aptr, ~0, pad);
170	aptr += pad;
171	}
172
173	/* Create the cursor */
174	cursor->curs = CreateCursor(
175	(HINSTANCE)GetWindowLongPtr(SDL_Window, GWLP_HINSTANCE),
176	hot_x, hot_y, allowed_x, allowed_y,
177	cursor->ands, cursor->xors);
178	if ( cursor->curs == NULL ) {
179	WIN_FreeWMCursor(NULL, cursor);
180	SDL_SetError("Windows couldn't create the requested cursor");
181	return(NULL);
182	}
183	return(cursor);
184	#endif /* USE_STATIC_CURSOR */
185	}
186
187	int WIN_ShowWMCursor(_THIS, WMcursor *cursor)
188	{
189	POINT mouse_pos;
190
191	if ( !this->screen ) {
192	return(0);
193	}
194
195	/* Set the window cursor to our cursor, if applicable */
196	if ( cursor != NULL ) {
197	SDL_hcursor = cursor->curs;
198	} else {
199	SDL_hcursor = NULL;
200	}
201	GetCursorPos(&mouse_pos);
202	if ( PtInRect(&SDL_bounds, mouse_pos) ) {
203	SetCursor(SDL_hcursor);
204	}
205	return(1);
206	}
207
208	void WIN_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
209	{
210	if ( mouse_relative) {
211	/* RJR: March 28, 2000
212	leave physical cursor at center of screen if
213	mouse hidden and grabbed */
214	SDL_PrivateMouseMotion(0, 0, x, y);
215	} else {
216	POINT pt;
217
218	/* With DirectInput the position doesn't follow
219	* the cursor, so it is set manually */
220	if ( DINPUT() ) {
221	SDL_PrivateMouseMotion(0, 0, x, y);
222	}
223
224	pt.x = x;
225	pt.y = y;
226	ClientToScreen(SDL_Window, &pt);
227	SetCursorPos(pt.x, pt.y);
228	}
229	}
230
231	/* Update the current mouse state and position */
232	void WIN_UpdateMouse(_THIS)
233	{
234	POINT pt;
235
236	/* Always unset SDL_APPMOUSEFOCUS to give the WM_MOUSEMOVE event
237	* handler a chance to install a TRACKMOUSEEVENT */
238	SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
239
240	GetCursorPos(&pt);
241	ScreenToClient(SDL_Window, &pt);
242	SDL_PrivateMouseMotion(0,0, (Sint16)pt.x, (Sint16)pt.y);
243	}
244
245	/* Check to see if we need to enter or leave mouse relative mode */
246	void WIN_CheckMouseMode(_THIS)
247	{
248	#ifndef _WIN32_WCE
249	/* If the mouse is hidden and input is grabbed, we use relative mode */
250	if ( !(SDL_cursorstate & CURSOR_VISIBLE) &&
251	(this->input_grab != SDL_GRAB_OFF) ) {
252	mouse_relative = 1;
253	} else {
254	mouse_relative = 0;
255	}
256	#else
257	mouse_relative = 0;
258	#endif
259	}