[sdl_omap.git] / src / video / bwindow / SDL_sysevents.cc

/*
    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"

#include <support/UTF8.h>
#include <stdio.h>
#include <string.h>
#include "SDL_error.h"
#include "SDL_events.h"
#include "SDL_BWin.h"
#include "SDL_lowvideo.h"

static SDLKey keymap[128];
int mouse_relative = 0;
extern "C" {

#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_sysevents_c.h"

void BE_PumpEvents(_THIS)
{
}

void BE_InitOSKeymap(_THIS)
{
		for ( uint i=0; i<SDL_TABLESIZE(keymap); ++i )
			keymap[i] = SDLK_UNKNOWN;

		keymap[0x01]		= SDLK_ESCAPE;
		keymap[B_F1_KEY]	= SDLK_F1;
		keymap[B_F2_KEY]	= SDLK_F2;
		keymap[B_F3_KEY]	= SDLK_F3;
		keymap[B_F4_KEY]	= SDLK_F4;
		keymap[B_F5_KEY]	= SDLK_F5;
		keymap[B_F6_KEY]	= SDLK_F6;
		keymap[B_F7_KEY]	= SDLK_F7;
		keymap[B_F8_KEY]	= SDLK_F8;
		keymap[B_F9_KEY]	= SDLK_F9;
		keymap[B_F10_KEY]	= SDLK_F10;
		keymap[B_F11_KEY]	= SDLK_F11;
		keymap[B_F12_KEY]	= SDLK_F12;
		keymap[B_PRINT_KEY]	= SDLK_PRINT;
		keymap[B_SCROLL_KEY]	= SDLK_SCROLLOCK;
		keymap[B_PAUSE_KEY]	= SDLK_PAUSE;
		keymap[0x11]		= SDLK_BACKQUOTE;
		keymap[0x12]		= SDLK_1;
		keymap[0x13]		= SDLK_2;
		keymap[0x14]		= SDLK_3;
		keymap[0x15]		= SDLK_4;
		keymap[0x16]		= SDLK_5;
		keymap[0x17]		= SDLK_6;
		keymap[0x18]		= SDLK_7;
		keymap[0x19]		= SDLK_8;
		keymap[0x1a]		= SDLK_9;
		keymap[0x1b]		= SDLK_0;
		keymap[0x1c]		= SDLK_MINUS;
		keymap[0x1d]		= SDLK_EQUALS;
		keymap[0x1e]		= SDLK_BACKSPACE;
		keymap[0x1f]		= SDLK_INSERT;
		keymap[0x20]		= SDLK_HOME;
		keymap[0x21]		= SDLK_PAGEUP;
		keymap[0x22]		= SDLK_NUMLOCK;
		keymap[0x23]		= SDLK_KP_DIVIDE;
		keymap[0x24]		= SDLK_KP_MULTIPLY;
		keymap[0x25]		= SDLK_KP_MINUS;
		keymap[0x26]		= SDLK_TAB;
		keymap[0x27]		= SDLK_q;
		keymap[0x28]		= SDLK_w;
		keymap[0x29]		= SDLK_e;
		keymap[0x2a]		= SDLK_r;
		keymap[0x2b]		= SDLK_t;
		keymap[0x2c]		= SDLK_y;
		keymap[0x2d]		= SDLK_u;
		keymap[0x2e]		= SDLK_i;
		keymap[0x2f]		= SDLK_o;
		keymap[0x30]		= SDLK_p;
		keymap[0x31]		= SDLK_LEFTBRACKET;
		keymap[0x32]		= SDLK_RIGHTBRACKET;
		keymap[0x33]		= SDLK_BACKSLASH;
		keymap[0x34]		= SDLK_DELETE;
		keymap[0x35]		= SDLK_END;
		keymap[0x36]		= SDLK_PAGEDOWN;
		keymap[0x37]		= SDLK_KP7;
		keymap[0x38]		= SDLK_KP8;
		keymap[0x39]		= SDLK_KP9;
		keymap[0x3a]		= SDLK_KP_PLUS;
		keymap[0x3b]		= SDLK_CAPSLOCK;
		keymap[0x3c]		= SDLK_a;
		keymap[0x3d]		= SDLK_s;
		keymap[0x3e]		= SDLK_d;
		keymap[0x3f]		= SDLK_f;
		keymap[0x40]		= SDLK_g;
		keymap[0x41]		= SDLK_h;
		keymap[0x42]		= SDLK_j;
		keymap[0x43]		= SDLK_k;
		keymap[0x44]		= SDLK_l;
		keymap[0x45]		= SDLK_SEMICOLON;
		keymap[0x46]		= SDLK_QUOTE;
		keymap[0x47]		= SDLK_RETURN;
		keymap[0x48]		= SDLK_KP4;
		keymap[0x49]		= SDLK_KP5;
		keymap[0x4a]		= SDLK_KP6;
		keymap[0x4b]		= SDLK_LSHIFT;
		keymap[0x4c]		= SDLK_z;
		keymap[0x4d]		= SDLK_x;
		keymap[0x4e]		= SDLK_c;
		keymap[0x4f]		= SDLK_v;
		keymap[0x50]		= SDLK_b;
		keymap[0x51]		= SDLK_n;
		keymap[0x52]		= SDLK_m;
		keymap[0x53]		= SDLK_COMMA;
		keymap[0x54]		= SDLK_PERIOD;
		keymap[0x55]		= SDLK_SLASH;
		keymap[0x56]		= SDLK_RSHIFT;
		keymap[0x57]		= SDLK_UP;
		keymap[0x58]		= SDLK_KP1;
		keymap[0x59]		= SDLK_KP2;
		keymap[0x5a]		= SDLK_KP3;
		keymap[0x5b]		= SDLK_KP_ENTER;
		keymap[0x5c]		= SDLK_LCTRL;
		keymap[0x5d]		= SDLK_LALT;
		keymap[0x5e]		= SDLK_SPACE;
		keymap[0x5f]		= SDLK_RALT;
		keymap[0x60]		= SDLK_RCTRL;
		keymap[0x61]		= SDLK_LEFT;
		keymap[0x62]		= SDLK_DOWN;
		keymap[0x63]		= SDLK_RIGHT;
		keymap[0x64]		= SDLK_KP0;
		keymap[0x65]		= SDLK_KP_PERIOD;
		keymap[0x66]		= SDLK_LMETA;
		keymap[0x67]		= SDLK_RMETA;
		keymap[0x68]		= SDLK_MENU;
		keymap[0x69]		= SDLK_EURO;
		keymap[0x6a]		= SDLK_KP_EQUALS;
		keymap[0x6b]		= SDLK_POWER;
}

}; /* Extern C */

void SDL_BWin::DispatchMessage(BMessage *msg, BHandler *target)
{
	switch (msg->what) {
		case B_MOUSE_MOVED:
		{
			SDL_VideoDevice *view = current_video;
			BPoint where;
			int32 transit;
			if (msg->FindPoint("where", &where) == B_OK && msg->FindInt32("be:transit", &transit) == B_OK) {
				int x, y;

				GetXYOffset(x, y);
				x = (int)where.x - x;
				y = (int)where.y - y;

				//BeSman: I need another method for cursor catching !!!
				if (view->input_grab != SDL_GRAB_OFF)
				{
					bool clipped = false;
					if ( x < 0 ) {
						x = 0;
						clipped = true;
					} else if ( x >= SDL_VideoSurface->w ) {
						x = (SDL_VideoSurface->w-1);
						clipped = true;
					}
					if ( y < 0 ) {
						y = 0;
						clipped = true;
					} else if ( y >= SDL_VideoSurface->h ) {
						y = (SDL_VideoSurface->h-1);
						clipped = true;
					}
					if ( clipped ) {
						BPoint edge;
						GetXYOffset(edge.x, edge.y);
						edge.x += x;
						edge.y += y;
						ConvertToScreen(&edge);
						set_mouse_position((int)edge.x, (int)edge.y);
					}
					transit = B_INSIDE_VIEW;
				}
				if (transit == B_EXITED_VIEW) {
					if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
						SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
						be_app->SetCursor(B_HAND_CURSOR);
					}
				} else {
					if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
						SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
						SDL_SetCursor(NULL);
					}

					if ( mouse_relative ) {
						int half_w = (SDL_VideoSurface->w/2);
						int half_h = (SDL_VideoSurface->h/2);
						x -= half_w;
						y -= half_h;
						if ( x || y ) {
							BPoint center;
							GetXYOffset(center.x, center.y);
							center.x += half_w;
							center.y += half_h;
							ConvertToScreen(&center);
							set_mouse_position((int)center.x, (int)center.y);
							SDL_PrivateMouseMotion(0, 1, x, y);
						}
					} else {
						SDL_PrivateMouseMotion(0, 0, x, y);
					}
				}
			}
			break;
		}

		case B_MOUSE_DOWN:
		{
			/*	it looks like mouse down is send only for first clicked
				button, each next is not send while last one is holded */
			int32 buttons;
			int sdl_buttons = 0;
			if (msg->FindInt32("buttons", &buttons) == B_OK) {
				/* Add any mouse button events */
				if (buttons & B_PRIMARY_MOUSE_BUTTON) {
					sdl_buttons |= SDL_BUTTON_LEFT;
				}
				if (buttons & B_SECONDARY_MOUSE_BUTTON) {
					sdl_buttons |= SDL_BUTTON_RIGHT;
				}
				if (buttons & B_TERTIARY_MOUSE_BUTTON) {
					sdl_buttons |= SDL_BUTTON_MIDDLE;
				}
				SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0);

				last_buttons = buttons;
			}
			break;
		}

		case B_MOUSE_UP:
		{
			/*	mouse up doesn't give which button was released,
				only state of buttons (after release, so it's always = 0),
				which is not what we need ;]
				So we need to store button in mouse down, and restore
				in mouse up :(
				mouse up is (similarly to mouse down) send only for
				first button down (ie. it's no send if we click another button
				without releasing previous one first) - but that's probably
				because of how drivers are written?, not BeOS itself. */
			int32 buttons;
			int sdl_buttons = 0;
			if (msg->FindInt32("buttons", &buttons) == B_OK) {
				/* Add any mouse button events */
				if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
					sdl_buttons |= SDL_BUTTON_LEFT;
				}
				if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
					sdl_buttons |= SDL_BUTTON_RIGHT;
				}
				if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
					sdl_buttons |= SDL_BUTTON_MIDDLE;
				}
				SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0);

				last_buttons = buttons;
			}
			break;
		}

		case B_MOUSE_WHEEL_CHANGED:
		{
			float x, y;
			x = y = 0;
			if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
				if (x < 0 || y < 0) {
					SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);
					SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);
				} else if (x > 0 || y > 0) {
					SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);
					SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);
				}
			}
			break;
		}

		case B_KEY_DOWN:
		case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
		{
			int32 key;
			int32 modifiers;
			int32 key_repeat;
			/* Workaround for SDL message queue being filled too fast because of BeOS own key-repeat mechanism */
			if (msg->FindInt32("be:key_repeat", &key_repeat) == B_OK && key_repeat > 0)
				break;

			if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
				SDL_keysym keysym;
				keysym.scancode = key;
				if (key < 128) {
					keysym.sym = keymap[key];
				} else {
					keysym.sym = SDLK_UNKNOWN;
				}
				/*	FIX THIS?
					it seems SDL_PrivateKeyboard() changes mod value
					anyway, and doesn't care about what we setup here */
				keysym.mod = KMOD_NONE;
				keysym.unicode = 0;
				if (SDL_TranslateUNICODE) {
					const char *bytes;
					if (msg->FindString("bytes", &bytes) == B_OK) {
						/*	FIX THIS?
							this cares only about first "letter",
							so if someone maps some key to print
							"BeOS rulez!" only "B" will be used. */
						keysym.unicode = Translate2Unicode(bytes);
					}
				}
				SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
			}
			break;
		}

		case B_KEY_UP:
		case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
		{
			int32 key;
			int32 modifiers;
			if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
				SDL_keysym keysym;
				keysym.scancode = key;
				if (key < 128) {
					keysym.sym = keymap[key];
				} else {
					keysym.sym = SDLK_UNKNOWN;
				}
				keysym.mod = KMOD_NONE; /* FIX THIS? */
				keysym.unicode = 0;
				if (SDL_TranslateUNICODE) {
					const char *bytes;
					if (msg->FindString("bytes", &bytes) == B_OK) {
						keysym.unicode = Translate2Unicode(bytes);
					}
				}
				SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
			}
			break;
		}

		default:
			/* move it after switch{} so it's always handled
				that way we keep BeOS feautures like:
				- CTRL+Q to close window (and other shortcuts)
				- PrintScreen to make screenshot into /boot/home
				- etc.. */
			//BDirectWindow::DispatchMessage(msg, target);
			break;
	}
	BDirectWindow::DispatchMessage(msg, target);
}

void SDL_BWin::DirectConnected(direct_buffer_info *info) {
	switch (info->buffer_state & B_DIRECT_MODE_MASK) {
		case B_DIRECT_START:
		case B_DIRECT_MODIFY:
			{
				int32 width = info->window_bounds.right -
					info->window_bounds.left + 1;
				int32 height = info->window_bounds.bottom -
					info->window_bounds.top + 1;
				SDL_PrivateResize(width, height);
				break;
			}
		default:
			break;
	}
}
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	#include <support/UTF8.h>
	25	#include <stdio.h>
	26	#include <string.h>
	27	#include "SDL_error.h"
	28	#include "SDL_events.h"
	29	#include "SDL_BWin.h"
	30	#include "SDL_lowvideo.h"
	31
	32	static SDLKey keymap[128];
	33	int mouse_relative = 0;
	34	extern "C" {
	35
	36	#include "../../events/SDL_sysevents.h"
	37	#include "../../events/SDL_events_c.h"
	38	#include "SDL_sysevents_c.h"
	39
	40	void BE_PumpEvents(_THIS)
	41	{
	42	}
	43
	44	void BE_InitOSKeymap(_THIS)
	45	{
	46	for ( uint i=0; i<SDL_TABLESIZE(keymap); ++i )
	47	keymap[i] = SDLK_UNKNOWN;
	48
	49	keymap[0x01] = SDLK_ESCAPE;
	50	keymap[B_F1_KEY] = SDLK_F1;
	51	keymap[B_F2_KEY] = SDLK_F2;
	52	keymap[B_F3_KEY] = SDLK_F3;
	53	keymap[B_F4_KEY] = SDLK_F4;
	54	keymap[B_F5_KEY] = SDLK_F5;
	55	keymap[B_F6_KEY] = SDLK_F6;
	56	keymap[B_F7_KEY] = SDLK_F7;
	57	keymap[B_F8_KEY] = SDLK_F8;
	58	keymap[B_F9_KEY] = SDLK_F9;
	59	keymap[B_F10_KEY] = SDLK_F10;
	60	keymap[B_F11_KEY] = SDLK_F11;
	61	keymap[B_F12_KEY] = SDLK_F12;
	62	keymap[B_PRINT_KEY] = SDLK_PRINT;
	63	keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
	64	keymap[B_PAUSE_KEY] = SDLK_PAUSE;
65	keymap[0x11] = SDLK_BACKQUOTE;
66	keymap[0x12] = SDLK_1;
67	keymap[0x13] = SDLK_2;
68	keymap[0x14] = SDLK_3;
69	keymap[0x15] = SDLK_4;
70	keymap[0x16] = SDLK_5;
71	keymap[0x17] = SDLK_6;
72	keymap[0x18] = SDLK_7;
73	keymap[0x19] = SDLK_8;
74	keymap[0x1a] = SDLK_9;
75	keymap[0x1b] = SDLK_0;
76	keymap[0x1c] = SDLK_MINUS;
77	keymap[0x1d] = SDLK_EQUALS;
78	keymap[0x1e] = SDLK_BACKSPACE;
79	keymap[0x1f] = SDLK_INSERT;
80	keymap[0x20] = SDLK_HOME;
81	keymap[0x21] = SDLK_PAGEUP;
82	keymap[0x22] = SDLK_NUMLOCK;
83	keymap[0x23] = SDLK_KP_DIVIDE;
84	keymap[0x24] = SDLK_KP_MULTIPLY;
85	keymap[0x25] = SDLK_KP_MINUS;
86	keymap[0x26] = SDLK_TAB;
87	keymap[0x27] = SDLK_q;
88	keymap[0x28] = SDLK_w;
89	keymap[0x29] = SDLK_e;
90	keymap[0x2a] = SDLK_r;
91	keymap[0x2b] = SDLK_t;
92	keymap[0x2c] = SDLK_y;
93	keymap[0x2d] = SDLK_u;
94	keymap[0x2e] = SDLK_i;
95	keymap[0x2f] = SDLK_o;
96	keymap[0x30] = SDLK_p;
97	keymap[0x31] = SDLK_LEFTBRACKET;
98	keymap[0x32] = SDLK_RIGHTBRACKET;
99	keymap[0x33] = SDLK_BACKSLASH;
100	keymap[0x34] = SDLK_DELETE;
101	keymap[0x35] = SDLK_END;
102	keymap[0x36] = SDLK_PAGEDOWN;
103	keymap[0x37] = SDLK_KP7;
104	keymap[0x38] = SDLK_KP8;
105	keymap[0x39] = SDLK_KP9;
106	keymap[0x3a] = SDLK_KP_PLUS;
107	keymap[0x3b] = SDLK_CAPSLOCK;
108	keymap[0x3c] = SDLK_a;
109	keymap[0x3d] = SDLK_s;
110	keymap[0x3e] = SDLK_d;
111	keymap[0x3f] = SDLK_f;
112	keymap[0x40] = SDLK_g;
113	keymap[0x41] = SDLK_h;
114	keymap[0x42] = SDLK_j;
115	keymap[0x43] = SDLK_k;
116	keymap[0x44] = SDLK_l;
117	keymap[0x45] = SDLK_SEMICOLON;
118	keymap[0x46] = SDLK_QUOTE;
119	keymap[0x47] = SDLK_RETURN;
120	keymap[0x48] = SDLK_KP4;
121	keymap[0x49] = SDLK_KP5;
122	keymap[0x4a] = SDLK_KP6;
123	keymap[0x4b] = SDLK_LSHIFT;
124	keymap[0x4c] = SDLK_z;
125	keymap[0x4d] = SDLK_x;
126	keymap[0x4e] = SDLK_c;
127	keymap[0x4f] = SDLK_v;
128	keymap[0x50] = SDLK_b;
129	keymap[0x51] = SDLK_n;
130	keymap[0x52] = SDLK_m;
131	keymap[0x53] = SDLK_COMMA;
132	keymap[0x54] = SDLK_PERIOD;
133	keymap[0x55] = SDLK_SLASH;
134	keymap[0x56] = SDLK_RSHIFT;
135	keymap[0x57] = SDLK_UP;
136	keymap[0x58] = SDLK_KP1;
137	keymap[0x59] = SDLK_KP2;
138	keymap[0x5a] = SDLK_KP3;
139	keymap[0x5b] = SDLK_KP_ENTER;
140	keymap[0x5c] = SDLK_LCTRL;
141	keymap[0x5d] = SDLK_LALT;
142	keymap[0x5e] = SDLK_SPACE;
143	keymap[0x5f] = SDLK_RALT;
144	keymap[0x60] = SDLK_RCTRL;
145	keymap[0x61] = SDLK_LEFT;
146	keymap[0x62] = SDLK_DOWN;
147	keymap[0x63] = SDLK_RIGHT;
148	keymap[0x64] = SDLK_KP0;
149	keymap[0x65] = SDLK_KP_PERIOD;
150	keymap[0x66] = SDLK_LMETA;
151	keymap[0x67] = SDLK_RMETA;
152	keymap[0x68] = SDLK_MENU;
153	keymap[0x69] = SDLK_EURO;
154	keymap[0x6a] = SDLK_KP_EQUALS;
155	keymap[0x6b] = SDLK_POWER;
156	}
157
158	}; /* Extern C */
159
160	void SDL_BWin::DispatchMessage(BMessage msg, BHandler target)
161	{
162	switch (msg->what) {
163	case B_MOUSE_MOVED:
164	{
165	SDL_VideoDevice *view = current_video;
166	BPoint where;
167	int32 transit;
168	if (msg->FindPoint("where", &where) == B_OK && msg->FindInt32("be:transit", &transit) == B_OK) {
169	int x, y;
170
171	GetXYOffset(x, y);
172	x = (int)where.x - x;
173	y = (int)where.y - y;
174
175	//BeSman: I need another method for cursor catching !!!
176	if (view->input_grab != SDL_GRAB_OFF)
177	{
178	bool clipped = false;
179	if ( x < 0 ) {
180	x = 0;
181	clipped = true;
182	} else if ( x >= SDL_VideoSurface->w ) {
183	x = (SDL_VideoSurface->w-1);
184	clipped = true;
185	}
186	if ( y < 0 ) {
187	y = 0;
188	clipped = true;
189	} else if ( y >= SDL_VideoSurface->h ) {
190	y = (SDL_VideoSurface->h-1);
191	clipped = true;
192	}
193	if ( clipped ) {
194	BPoint edge;
195	GetXYOffset(edge.x, edge.y);
196	edge.x += x;
197	edge.y += y;
198	ConvertToScreen(&edge);
199	set_mouse_position((int)edge.x, (int)edge.y);
200	}
201	transit = B_INSIDE_VIEW;
202	}
203	if (transit == B_EXITED_VIEW) {
204	if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {
205	SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
206	be_app->SetCursor(B_HAND_CURSOR);
207	}
208	} else {
209	if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
210	SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
211	SDL_SetCursor(NULL);
212	}
213
214	if ( mouse_relative ) {
215	int half_w = (SDL_VideoSurface->w/2);
216	int half_h = (SDL_VideoSurface->h/2);
217	x -= half_w;
218	y -= half_h;
219	if ( x \|\| y ) {
220	BPoint center;
221	GetXYOffset(center.x, center.y);
222	center.x += half_w;
223	center.y += half_h;
224	ConvertToScreen(&center);
225	set_mouse_position((int)center.x, (int)center.y);
226	SDL_PrivateMouseMotion(0, 1, x, y);
227	}
228	} else {
229	SDL_PrivateMouseMotion(0, 0, x, y);
230	}
231	}
232	}
233	break;
234	}
235
236	case B_MOUSE_DOWN:
237	{
238	/* it looks like mouse down is send only for first clicked
239	button, each next is not send while last one is holded */
240	int32 buttons;
241	int sdl_buttons = 0;
242	if (msg->FindInt32("buttons", &buttons) == B_OK) {
243	/* Add any mouse button events */
244	if (buttons & B_PRIMARY_MOUSE_BUTTON) {
245	sdl_buttons \|= SDL_BUTTON_LEFT;
246	}
247	if (buttons & B_SECONDARY_MOUSE_BUTTON) {
248	sdl_buttons \|= SDL_BUTTON_RIGHT;
249	}
250	if (buttons & B_TERTIARY_MOUSE_BUTTON) {
251	sdl_buttons \|= SDL_BUTTON_MIDDLE;
252	}
253	SDL_PrivateMouseButton(SDL_PRESSED, sdl_buttons, 0, 0);
254
255	last_buttons = buttons;
256	}
257	break;
258	}
259
260	case B_MOUSE_UP:
261	{
262	/* mouse up doesn't give which button was released,
263	only state of buttons (after release, so it's always = 0),
264	which is not what we need ;]
265	So we need to store button in mouse down, and restore
266	in mouse up :(
267	mouse up is (similarly to mouse down) send only for
268	first button down (ie. it's no send if we click another button
269	without releasing previous one first) - but that's probably
270	because of how drivers are written?, not BeOS itself. */
271	int32 buttons;
272	int sdl_buttons = 0;
273	if (msg->FindInt32("buttons", &buttons) == B_OK) {
274	/* Add any mouse button events */
275	if ((buttons ^ B_PRIMARY_MOUSE_BUTTON) & last_buttons) {
276	sdl_buttons \|= SDL_BUTTON_LEFT;
277	}
278	if ((buttons ^ B_SECONDARY_MOUSE_BUTTON) & last_buttons) {
279	sdl_buttons \|= SDL_BUTTON_RIGHT;
280	}
281	if ((buttons ^ B_TERTIARY_MOUSE_BUTTON) & last_buttons) {
282	sdl_buttons \|= SDL_BUTTON_MIDDLE;
283	}
284	SDL_PrivateMouseButton(SDL_RELEASED, sdl_buttons, 0, 0);
285
286	last_buttons = buttons;
287	}
288	break;
289	}
290
291	case B_MOUSE_WHEEL_CHANGED:
292	{
293	float x, y;
294	x = y = 0;
295	if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK && msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {
296	if (x < 0 \|\| y < 0) {
297	SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);
298	SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);
299	} else if (x > 0 \|\| y > 0) {
300	SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);
301	SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);
302	}
303	}
304	break;
305	}
306
307	case B_KEY_DOWN:
308	case B_UNMAPPED_KEY_DOWN: /* modifier keys are unmapped */
309	{
310	int32 key;
311	int32 modifiers;
312	int32 key_repeat;
313	/* Workaround for SDL message queue being filled too fast because of BeOS own key-repeat mechanism */
314	if (msg->FindInt32("be:key_repeat", &key_repeat) == B_OK && key_repeat > 0)
315	break;
316
317	if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
318	SDL_keysym keysym;
319	keysym.scancode = key;
320	if (key < 128) {
321	keysym.sym = keymap[key];
322	} else {
323	keysym.sym = SDLK_UNKNOWN;
324	}
325	/* FIX THIS?
326	it seems SDL_PrivateKeyboard() changes mod value
327	anyway, and doesn't care about what we setup here */
328	keysym.mod = KMOD_NONE;
329	keysym.unicode = 0;
330	if (SDL_TranslateUNICODE) {
331	const char *bytes;
332	if (msg->FindString("bytes", &bytes) == B_OK) {
333	/* FIX THIS?
334	this cares only about first "letter",
335	so if someone maps some key to print
336	"BeOS rulez!" only "B" will be used. */
337	keysym.unicode = Translate2Unicode(bytes);
338	}
339	}
340	SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
341	}
342	break;
343	}
344
345	case B_KEY_UP:
346	case B_UNMAPPED_KEY_UP: /* modifier keys are unmapped */
347	{
348	int32 key;
349	int32 modifiers;
350	if (msg->FindInt32("key", &key) == B_OK && msg->FindInt32("modifiers", &modifiers) == B_OK) {
351	SDL_keysym keysym;
352	keysym.scancode = key;
353	if (key < 128) {
354	keysym.sym = keymap[key];
355	} else {
356	keysym.sym = SDLK_UNKNOWN;
357	}
358	keysym.mod = KMOD_NONE; /* FIX THIS? */
359	keysym.unicode = 0;
360	if (SDL_TranslateUNICODE) {
361	const char *bytes;
362	if (msg->FindString("bytes", &bytes) == B_OK) {
363	keysym.unicode = Translate2Unicode(bytes);
364	}
365	}
366	SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
367	}
368	break;
369	}
370
371	default:
372	/* move it after switch{} so it's always handled
373	that way we keep BeOS feautures like:
374	- CTRL+Q to close window (and other shortcuts)
375	- PrintScreen to make screenshot into /boot/home
376	- etc.. */
377	//BDirectWindow::DispatchMessage(msg, target);
378	break;
379	}
380	BDirectWindow::DispatchMessage(msg, target);
381	}
382
383	void SDL_BWin::DirectConnected(direct_buffer_info *info) {
384	switch (info->buffer_state & B_DIRECT_MODE_MASK) {
385	case B_DIRECT_START:
386	case B_DIRECT_MODIFY:
387	{
388	int32 width = info->window_bounds.right -
389	info->window_bounds.left + 1;
390	int32 height = info->window_bounds.bottom -
391	info->window_bounds.top + 1;
392	SDL_PrivateResize(width, height);
393	break;
394	}
395	default:
396	break;
397	}
398	}