xref: /external/qemu/distrib/sdl-1.2.15/src/video/bwindow/SDL_sysevents.cc

/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2012 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"
#include "../SDL_cursor_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);
#if SDL_VIDEO_OPENGL
					// for some reason, SDL_EraseCursor fails for OpenGL
					if (this->the_view != this->SDL_GLView)
#endif
							SDL_EraseCursor(SDL_VideoSurface);
						be_app->SetCursor(B_HAND_CURSOR);
					}
				} else {
					if ( !(SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {
						SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
#if SDL_VIDEO_OPENGL
					// for some reason, SDL_EraseCursor fails for OpenGL
					if (this->the_view != this->SDL_GLView)
#endif
							SDL_EraseCursor(SDL_VideoSurface);
						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;
				int32 height = info->window_bounds.bottom -
					info->window_bounds.top;
				SDL_PrivateResize(width, height);
				break;
			}
		default:
			break;
	}
#if SDL_VIDEO_OPENGL
	// If it is a BGLView, it is apparently required to
	// call DirectConnected() on it as well
	if (this->the_view == this->SDL_GLView)
		this->SDL_GLView->DirectConnected(info);
#endif
}