/*

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

*/

#ifndef _SDL_BWin_h

#define _SDL_BWin_h

#include "SDL_config.h"

#include <stdio.h>

#include <AppKit.h>

#include <InterfaceKit.h>

#include <be/game/DirectWindow.h>

#include <be/opengl/GLView.h>

#endif

#include "SDL_events.h"

#include "SDL_BView.h"

extern "C"

{

};

public:

SDL_BWin (BRect bounds):BDirectWindow (bounds, "Untitled",

B_TITLED_WINDOW, 0)

{

InitKeyboard ();

last_buttons = 0;

the_view = NULL;

SDL_View = NULL;

Unlock ();

shown = false;

inhibit_resize = false;

}

virtual ~ SDL_BWin ()

{

Lock ();

if (the_view) {

if (the_view == SDL_GLView) {

SDL_GLView->UnlockGL ();

}

RemoveChild (the_view);

the_view = NULL;

}

Unlock ();

if (SDL_GLView) {

delete SDL_GLView;

}

if (SDL_View) {

delete SDL_View;

}

}

virtual void InitKeyboard (void)

{

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;

}

/* Override the Show() method so we can tell when we've been shown */

virtual void Show (void)

{

BWindow::Show ();

shown = true;

}

virtual bool Shown (void)

{

return (shown);

}

/* If called, the next resize event will not be forwarded to SDL. */

virtual void InhibitResize (void)

{

inhibit_resize = true;

}

/* Handle resizing of the window */

virtual void FrameResized (float width, float height)

{

if (inhibit_resize)

inhibit_resize = false;

else

SDL_PrivateResize ((int) width, (int) height);

}

virtual int CreateView (Uint32 flags, Uint32 gl_flags)

{

int retval;

retval = 0;

Lock ();

if (flags & SDL_INTERNALOPENGL) {

if (SDL_GLView == NULL) {

SDL_GLView = new BGLView (Bounds (), "SDL GLView",

B_FOLLOW_ALL_SIDES,

(B_WILL_DRAW | B_FRAME_EVENTS),

gl_flags);

}

if (the_view != SDL_GLView) {

if (the_view) {

RemoveChild (the_view);

}

AddChild (SDL_GLView);

SDL_GLView->LockGL ();

the_view = SDL_GLView;

}

SDL_SetError ("OpenGL support not enabled");

retval = -1;

} else {

if (SDL_View == NULL) {

SDL_View = new SDL_BView (Bounds ());

}

if (the_view != SDL_View) {

if (the_view) {

if (the_view == SDL_GLView) {

SDL_GLView->UnlockGL ();

}

RemoveChild (the_view);

}

AddChild (SDL_View);

the_view = SDL_View;

}

}

Unlock ();

return (retval);

}

virtual void SetBitmap (BBitmap * bitmap)

{

SDL_View->SetBitmap (bitmap);

}

virtual void SetXYOffset (int x, int y)

{

if (the_view == SDL_GLView) {

return;

}

SDL_View->SetXYOffset (x, y);

}

virtual void GetXYOffset (int &x, int &y)

{

if (the_view == SDL_GLView) {

x = 0;

y = 0;

return;

}

SDL_View->GetXYOffset (x, y);

}

virtual bool BeginDraw (void)

{

return (Lock ());

}

virtual void DrawAsync (BRect updateRect)

{

SDL_View->DrawAsync (updateRect);

}

virtual void EndDraw (void)

{

SDL_View->Sync ();

Unlock ();

}

virtual void SwapBuffers (void)

{

SDL_GLView->UnlockGL ();

SDL_GLView->LockGL ();

SDL_GLView->SwapBuffers ();

}

virtual BView *View (void)

{

return (the_view);

}

/* Hook functions -- overridden */

virtual void Minimize (bool minimize)

{

/* This is only called when mimimized, not when restored */

//SDL_PrivateAppActive(minimize, SDL_APPACTIVE);

BWindow::Minimize (minimize);

}

virtual void WindowActivated (bool active)

{

SDL_PrivateAppActive (active, SDL_APPINPUTFOCUS);

}

virtual bool QuitRequested (void)

{

if (SDL_BeAppActive > 0) {

SDL_PrivateQuit ();

/* We don't ever actually close the window here because

the application should respond to the quit request,

or ignore it as desired.

*/

return (false);

}

return (true); /* Close the app window */

}

virtual void Quit ()

{

if (!IsLocked ())

Lock ();

BDirectWindow::Quit ();

}

virtual int16 Translate2Unicode (const char *buf)

{

int32 state, srclen, dstlen;

unsigned char destbuf[2];

Uint16 unicode = 0;

if ((uchar) buf[0] > 127) {

state = 0;

srclen = SDL_strlen (buf);

dstlen = sizeof (destbuf);

convert_from_utf8 (B_UNICODE_CONVERSION, buf, &srclen,

(char *) destbuf, &dstlen, &state);

unicode = destbuf[0];

unicode <<= 8;

unicode |= destbuf[1];

} else

unicode = buf[0];

/* For some reason function keys map to control characters */

switch (unicode) {

case CTRL ('A'):

case CTRL ('B'):

case CTRL ('C'):

case CTRL ('D'):

case CTRL ('E'):

case CTRL ('K'):

case CTRL ('L'):

case CTRL ('P'):

if (!(SDL_GetModState () & KMOD_CTRL))

unicode = 0;

break;

/* Keyboard input maps newline to carriage return */

case '\n':

unicode = '\r';

break;

default:

break;

}

return unicode;

}

virtual void DispatchMessage (BMessage * msg, BHandler * target)

{

switch (msg->what) {

case B_MOUSE_MOVED:

{

BPoint where;

int32 transit;

if (msg->FindPoint ("where", &where) == B_OK

&& msg->FindInt32 ("be:transit", &transit) == B_OK) {

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);

}

GetXYOffset (x, y);

x = (int) where.x - x;

y = (int) where.y - y;

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 > 0) && (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 > 0) && (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);

}

private:

SDL_BView *SDL_View;

BView *the_view;

bool shown;

bool inhibit_resize;

int32 last_buttons;

SDLKey keymap[128];

};

#endif /* _SDL_BWin_h */