/*

SDL - Simple DirectMedia Layer

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

modify it under the terms of the GNU Library General Public

License as published by the Free Software Foundation; either

version 2 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

Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with this library; if not, write to the Free

Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

Sam Lantinga

*/

#ifdef SAVE_RCSID

static char rcsid =

"@(#) $Id$";

#endif

#ifndef _SDL_BWin_h

#define _SDL_BWin_h

#include <stdio.h>

#include <AppKit.h>

#include <InterfaceKit.h>

#include <be/game/DirectWindow.h>

#ifdef HAVE_OPENGL

#include <be/opengl/GLView.h>

#endif

#include "SDL_BeApp.h"

#include "SDL_events.h"

#include "SDL_BView.h"

extern "C" {

#include "SDL_events_c.h"

};

class SDL_BWin : public BDirectWindow

{

public:

SDL_BWin(BRect bounds) :

BDirectWindow(bounds, "Untitled", B_TITLED_WINDOW, 0) {

InitKeyboard();

last_buttons = 0;

the_view = NULL;

#ifdef HAVE_OPENGL

SDL_GLView = NULL;

#endif

SDL_View = NULL;

Unlock();

shown = false;

inhibit_resize = false;

}

virtual ~SDL_BWin() {

Lock();

if ( the_view ) {

#ifdef HAVE_OPENGL

if ( the_view == SDL_GLView ) {

SDL_GLView->UnlockGL();

}

#endif

RemoveChild(the_view);

the_view = NULL;

}

Unlock();

#ifdef HAVE_OPENGL

if ( SDL_GLView ) {

delete SDL_GLView;

}

#endif

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

}

int retval;

retval = 0;

Lock();

if ( flags & SDL_OPENGL ) {

#ifdef HAVE_OPENGL

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;

}

#else

SDL_SetError("OpenGL support not enabled");

retval = -1;

#endif

} else {

if ( SDL_View == NULL ) {

SDL_View = new SDL_BView(Bounds());

}

if ( the_view != SDL_View ) {

if ( the_view ) {

#ifdef HAVE_OPENGL

if ( the_view == SDL_GLView ) {

SDL_GLView->UnlockGL();

}

#endif

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

#ifdef HAVE_OPENGL

if ( the_view == SDL_GLView ) {

return;

}

#endif

SDL_View->SetXYOffset(x, y);

}

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

#ifdef HAVE_OPENGL

if ( the_view == SDL_GLView ) {

x = 0;

y = 0;

return;

}

#endif

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

}

#ifdef HAVE_OPENGL

virtual void SwapBuffers(void) {

SDL_GLView->UnlockGL();

SDL_GLView->LockGL();

SDL_GLView->SwapBuffers();

}

#endif

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

# define CTRL(X) ((X)-'@')

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

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

}

private:

#ifdef HAVE_OPENGL

BGLView *SDL_GLView;

#endif

SDL_BView *SDL_View;

BView *the_view;

bool shown;

bool inhibit_resize;

int32 last_buttons;

SDLKey keymap[128];

};

#endif /* _SDL_BWin_h */