/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

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

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

#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) {

//BeSman: I need another method for cursor catching !!!

if(view->input_grab != SDL_GRAB_OFF)

{

BPoint center;

center.x = (SDL_VideoSurface->w/2);

center.y = (SDL_VideoSurface->h/2);

BPoint delta = where - center;

if(delta.x > center.x)

SDL_WarpMouse((int)center.x*2,(int)where.y);

if(delta.x < -center.x)

SDL_WarpMouse(0,(int)where.y);

if(delta.y > center.y)

SDL_WarpMouse((int)where.x,(int)center.y*2);

if(delta.y < -center.y)

SDL_WarpMouse((int)where.x,0);

if((delta.x-1 < -center.x)&&(delta.y-1 < -center.y))

SDL_WarpMouse(1,1);

if((delta.x-1 < -center.x)&&(delta.y+1 > center.y))

SDL_WarpMouse(1,(int)center.y*2-1);

if((delta.x+1 > center.x)&&(delta.y-1 < -center.y))

SDL_WarpMouse((int)center.x*2-1,1);

if((delta.x+1 > center.x)&&(delta.y+1 > center.y))

SDL_WarpMouse((int)center.x*2-1,(int)center.y*2-1);

}

if (transit == B_EXITED_VIEW) {

if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) {

SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);

// be_app->SetCursor(B_HAND_CURSOR);

}

} else {

int x, y;

if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) {

SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);

SDL_SetCursor(NULL);

}

x = (int)where.x;

y = (int)where.y;

if ( mouse_relative ) {

BPoint center;

center.x = (SDL_VideoSurface->w/2);

center.y = (SDL_VideoSurface->h/2);

x -= (int)center.x;

y -= (int)center.y;

if ( x || y ) {

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 ( y ) {

if (y < 0) {

SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELDOWN, 0, 0);

SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELDOWN, 0, 0);

} else {

SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELUP, 0, 0);

SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELUP, 0, 0);

}

}

if ( x ) {

if (x < 0) {

SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELRIGHT, 0, 0);

SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELRIGHT, 0, 0);

} else {

SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_WHEELLEFT, 0, 0);

SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_WHEELLEFT, 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);

}