/*

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

extern int mouse_relative;

};

class SDL_BWin : public BDirectWindow

{

public:

SDL_BWin(BRect bounds) :

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

SDL_GLView = NULL;

#endif

SDL_View = NULL;

Unlock();

shown = false;

inhibit_resize = false;

}

virtual ~SDL_BWin() {

Lock();

if ( the_view ) {

if ( the_view == SDL_GLView ) {

SDL_GLView->UnlockGL();

}

#endif

RemoveChild(the_view);

the_view = NULL;

}

Unlock();

if ( SDL_GLView ) {

delete SDL_GLView;

}

#endif

if ( SDL_View ) {

delete SDL_View;

}

}

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

if ( SDL_GLView == NULL ) {

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

}

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

RemoveChild(the_view);

}

AddChild(SDL_View);

the_view = SDL_View;

}

}

#if SDL_VIDEO_OPENGL

if ( the_view == SDL_GLView ) {

SDL_GLView->UnlockGL();

}

#endif

Unlock();

return(retval);

}

virtual void SetBitmap(BBitmap *bitmap) {

SDL_View->SetBitmap(bitmap);

}

virtual void SetXYOffset(int x, int y) {

#if SDL_VIDEO_OPENGL

if ( the_view == SDL_GLView ) {

return;

}

#endif

SDL_View->SetXYOffset(x, y);

}

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

#if SDL_VIDEO_OPENGL

if ( the_view == SDL_GLView ) {

x = 0;

y = 0;

return;

}

#endif

SDL_View->GetXYOffset(x, y);

}

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

#if SDL_VIDEO_OPENGL

if ( the_view == SDL_GLView ) {

x = 0.0f;

y = 0.0f;

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

}

virtual void SwapBuffers(void) {

SDL_GLView->UnlockGL();

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.

*/

#if SDL_VIDEO_OPENGL

if ( SDL_GLView != NULL ) {

SDL_GLView->EnableDirectMode(false);

}

#endif

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;

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 DirectConnected(direct_buffer_info *info);

BGLView *SDL_GLView;

#endif

SDL_BView *SDL_View;

BView *the_view;

bool shown;

bool inhibit_resize;

};

#endif /* _SDL_BWin_h */