/*

  Simple DirectMedia Layer

  Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>

  This software is provided 'as-is', without any express or implied

  warranty.  In no event will the authors be held liable for any damages

  arising from the use of this software.

  Permission is granted to anyone to use this software for any purpose,

  including commercial applications, and to alter it and redistribute it

  freely, subject to the following restrictions:

  1. The origin of this software must not be misrepresented; you must not

     claim that you wrote the original software. If you use this software

     in a product, an acknowledgment in the product documentation would be

     appreciated but is not required.

  2. Altered source versions must be plainly marked as such, and must not be

     misrepresented as being the original software.

  3. This notice may not be removed or altered from any source distribution.

*/

#ifndef _SDL_BWin_h

#define _SDL_BWin_h

#ifdef __cplusplus

extern "C" {

#endif

#include "SDL_config.h"

#include "SDL.h"

#include "SDL_syswm.h"

#include "SDL_bframebuffer.h"

#ifdef __cplusplus

}

#endif

#include <stdio.h>

#include <AppKit.h>

#include <InterfaceKit.h>

#include <be/game/DirectWindow.h>

#if SDL_VIDEO_OPENGL

#include <be/opengl/GLView.h>

#endif

#include "SDL_events.h"

#include "../../main/beos/SDL_BApp.h"

enum WinCommands {

	BWIN_MOVE_WINDOW,

	BWIN_RESIZE_WINDOW,

	BWIN_SHOW_WINDOW,

	BWIN_HIDE_WINDOW,

	BWIN_MAXIMIZE_WINDOW,

	BWIN_MINIMIZE_WINDOW,

	BWIN_RESTORE_WINDOW,

	BWIN_SET_TITLE,

	BWIN_SET_BORDERED,

	BWIN_FULLSCREEN

};

class SDL_BWin:public BDirectWindow

{

  public:

  	/* Constructor/Destructor */

    SDL_BWin(BRect bounds, window_look look, uint32 flags)

        : BDirectWindow(bounds, "Untitled", look, B_NORMAL_WINDOW_FEEL, flags)

    {

        _last_buttons = 0;

#if SDL_VIDEO_OPENGL

        _SDL_GLView = NULL;

#endif

        _shown = false;

        _inhibit_resize = false;

        _mouse_focused = false;

        _prev_frame = NULL;

        /* Handle framebuffer stuff */

        _connected = _connection_disabled = false;

        _buffer_created = _buffer_dirty = false;

        _trash_window_buffer = false;

        _buffer_locker = new BLocker();

        _bitmap = NULL;

#ifdef DRAWTHREAD

        _draw_thread_id = spawn_thread(BE_DrawThread, "drawing_thread",

        					B_NORMAL_PRIORITY, (void*) this);

        resume_thread(_draw_thread_id);

#endif

    }

    virtual ~ SDL_BWin()

    {

        Lock();

        _connection_disabled = true;

        int32 result;

#if SDL_VIDEO_OPENGL

        if (_SDL_GLView) {

            _SDL_GLView->UnlockGL();

            RemoveChild(_SDL_GLView);	/* Why was this outside the if

            								statement before? */

        }

#endif    

        Unlock();

#if SDL_VIDEO_OPENGL

        if (_SDL_GLView) {

            delete _SDL_GLView;

        }

#endif

        /* Clean up framebuffer stuff */

        _buffer_locker->Lock();

#ifdef DRAWTHREAD

        wait_for_thread(_draw_thread_id, &result);

#endif

        free(_clips);

        delete _buffer_locker;

    }

    /* * * * * OpenGL functionality * * * * */

#if SDL_VIDEO_OPENGL

    virtual BGLView *CreateGLView(Uint32 gl_flags) {

        Lock();

        if (_SDL_GLView == NULL) {

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

                                     B_FOLLOW_ALL_SIDES,

                                     (B_WILL_DRAW | B_FRAME_EVENTS),

                                     gl_flags);

        }

        AddChild(_SDL_GLView);

        _SDL_GLView->EnableDirectMode(true);

        _SDL_GLView->LockGL();	/* "New" GLViews are created */

        Unlock();

        return (_SDL_GLView);

    }

    virtual void RemoveGLView() {

    	Lock();

    	if(_SDL_GLView) {

    		_SDL_GLView->UnlockGL();

    		RemoveChild(_SDL_GLView);

    	}

    	Unlock();

    }

    virtual void SwapBuffers(void) {

		_SDL_GLView->UnlockGL();

		_SDL_GLView->LockGL();

		_SDL_GLView->SwapBuffers();

	}

#endif

    /* * * * * Framebuffering* * * * */

    virtual void DirectConnected(direct_buffer_info *info) {

    	if(!_connected && _connection_disabled) {

    		return;

    	}

		/* Determine if the pixel buffer is usable after this update */

		_trash_window_buffer =		_trash_window_buffer

								|| ((info->buffer_state & B_BUFFER_RESIZED)

    							|| (info->buffer_state & B_BUFFER_RESET)

    							|| (info->driver_state == B_MODE_CHANGED));

    	LockBuffer();

    	switch(info->buffer_state & B_DIRECT_MODE_MASK) {

    	case B_DIRECT_START:

    		_connected = true;

    	case B_DIRECT_MODIFY:

    		if(_clips) {

    			free(_clips);

    			_clips = NULL;

    		}

    		_num_clips = info->clip_list_count;

    		_clips = (clipping_rect *)malloc(_num_clips*sizeof(clipping_rect));

    		if(_clips) {

    			memcpy(_clips, info->clip_list,

    				_num_clips*sizeof(clipping_rect));

    			_bits = (uint8*) info->bits;

    			_row_bytes = info->bytes_per_row;

    			_bounds = info->window_bounds;

    			_bytes_per_px = info->bits_per_pixel / 8;

    			_buffer_dirty = true;

    		}

    		break;

    	case B_DIRECT_STOP:

    		_connected = false;

    		break;

    	}

#if SDL_VIDEO_OPENGL

		if(_SDL_GLView) {

			_SDL_GLView->DirectConnected(info);

		}

#endif

    	/* Call the base object directconnected */

    	BDirectWindow::DirectConnected(info);

    	UnlockBuffer();

    }

    /* * * * * Event sending * * * * */

    /* Hook functions */

    virtual void FrameMoved(BPoint origin) {

    	/* Post a message to the BApp so that it can handle the window event */

    	BMessage msg(BAPP_WINDOW_MOVED);

		msg.AddInt32("window-x", (int)origin.x);

		msg.AddInt32("window-y", (int)origin.y);

    	_PostWindowEvent(msg);

		/* Perform normal hook operations */

    	BDirectWindow::FrameMoved(origin);

    }

    virtual void FrameResized(float width, float height) {

    	/* Post a message to the BApp so that it can handle the window event */

    	BMessage msg(BAPP_WINDOW_RESIZED);

		msg.AddInt32("window-w", (int)width + 1);

		msg.AddInt32("window-h", (int)height + 1);

    	_PostWindowEvent(msg);

		/* Perform normal hook operations */

    	BDirectWindow::FrameResized(width, height);

    }

	virtual bool QuitRequested() {

    	BMessage msg(BAPP_WINDOW_CLOSE_REQUESTED);

    	_PostWindowEvent(msg);

    	/* We won't allow a quit unless asked by DestroyWindow() */

    	return false;	

    }

    virtual void WindowActivated(bool active) {

    	BMessage msg(BAPP_KEYBOARD_FOCUS);	/* Mouse focus sold separately */

    	_PostWindowEvent(msg);

    }

    virtual void Zoom(BPoint origin,

				float width,

				float height) {

		BMessage msg(BAPP_MAXIMIZE);	/* Closest thing to maximization Haiku has */

    	_PostWindowEvent(msg);

    	/* Before the window zooms, record its size */

    	if( !_prev_frame )

    		_prev_frame = new BRect(Frame());

    	/* Perform normal hook operations */

    	BDirectWindow::Zoom(origin, width, height);

    }

    /* Member functions */

    virtual void Show() {

    	while(IsHidden()) {

    		BDirectWindow::Show();

    	}

    	_shown = true;

    	BMessage msg(BAPP_SHOW);

    	_PostWindowEvent(msg);

    }

    virtual void Hide() {

    	BDirectWindow::Hide();

    	_shown = false;

    	BMessage msg(BAPP_HIDE);

    	_PostWindowEvent(msg);

    }

    virtual void Minimize(bool minimize) {

    	BDirectWindow::Minimize(minimize);

    	int32 minState = (minimize ? BAPP_MINIMIZE : BAPP_RESTORE);

    	BMessage msg(minState);

    	_PostWindowEvent(msg);

    }

    /* BView message interruption */

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

    {

        BPoint where;	/* Used by mouse moved */

        int32 buttons;	/* Used for mouse button events */

        int32 key;		/* Used for key events */

        switch (msg->what) {

        case B_MOUSE_MOVED:

            int32 transit;

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

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

            	_MouseMotionEvent(where, transit);

            }

            /* FIXME: Apparently a button press/release event might be dropped

               if made before before a different button is released.  Does

               B_MOUSE_MOVED have the data needed to check if a mouse button

               state has changed? */

            if (msg->FindInt32("buttons", &buttons) == B_OK) {

				_MouseButtonEvent(buttons);

            }

            break;

        case B_MOUSE_DOWN:

        case B_MOUSE_UP:

            /* _MouseButtonEvent() detects any and all buttons that may have

               changed state, as well as that button's new state */

            if (msg->FindInt32("buttons", &buttons) == B_OK) {

				_MouseButtonEvent(buttons);

            }

            break;

        case B_MOUSE_WHEEL_CHANGED:

        	float x, y;

        	if (msg->FindFloat("be:wheel_delta_x", &x) == B_OK

        		&& msg->FindFloat("be:wheel_delta_y", &y) == B_OK) {

        			_MouseWheelEvent((int)x, (int)y);

        	}

        	break;

        case B_KEY_DOWN:

        case B_UNMAPPED_KEY_DOWN:      /* modifier keys are unmapped */

        	if (msg->FindInt32("key", &key) == B_OK) {

        		_KeyEvent((SDL_Scancode)key, SDL_PRESSED);

        	}

        	break;

        case B_KEY_UP:

        case B_UNMAPPED_KEY_UP:        /* modifier keys are unmapped */

        	if (msg->FindInt32("key", &key) == B_OK) {

            	_KeyEvent(key, SDL_RELEASED);

            }

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

    }

    /* Handle command messages */

    virtual void MessageReceived(BMessage* message) {

    	switch (message->what) {

    		/* Handle commands from SDL */

    		case BWIN_SET_TITLE:

    			_SetTitle(message);

    			break;

    		case BWIN_MOVE_WINDOW: 

    			_MoveTo(message);

    			break;

    		case BWIN_RESIZE_WINDOW:

    			_ResizeTo(message);

    			break;

    		case BWIN_SET_BORDERED:

    			_SetBordered(message);

    			break;

    		case BWIN_SHOW_WINDOW:

    			Show();

    			break;

    		case BWIN_HIDE_WINDOW:

    			Hide();

    			break;

    		case BWIN_MAXIMIZE_WINDOW:

    			BWindow::Zoom();

    			break;

			case BWIN_MINIMIZE_WINDOW:

				Minimize(true);

    			break;

    		case BWIN_RESTORE_WINDOW:

    			_Restore();

    			break;

    		case BWIN_FULLSCREEN:

    			_SetFullScreen(message);

    			break;

    		default:

    			/* Perform normal message handling */

    			BDirectWindow::MessageReceived(message);

    			break;

    	}

    }

	/* Accessor methods */

	bool IsShown() { return _shown; }

	int32 GetID() { return _id; }

	uint32 GetRowBytes() { return _row_bytes; }

	int32 GetFbX() { return _bounds.left; }

	int32 GetFbY() { return _bounds.top; }

	bool ConnectionEnabled() { return !_connection_disabled; }

	bool Connected() { return _connected; }

	clipping_rect *GetClips() { return _clips; }

	int32 GetNumClips() { return _num_clips; }

	uint8* GetBufferPx() { return _bits; }

	int32 GetBytesPerPx() { return _bytes_per_px; }

	bool CanTrashWindowBuffer() { return _trash_window_buffer; }

	bool BufferExists() { return _buffer_created; }

	bool BufferIsDirty() { return _buffer_dirty; }

	BBitmap *GetBitmap() { return _bitmap; }

#if SDL_VIDEO_OPENGL

	BGLView *GetGLView() { return _SDL_GLView; }

#endif

	/* Setter methods */

	void SetID(int32 id) { _id = id; }

	void SetBufferExists(bool bufferExists) { _buffer_created = bufferExists; }

	void LockBuffer() {	_buffer_locker->Lock(); }

	void UnlockBuffer() { _buffer_locker->Unlock(); }

	void SetBufferDirty(bool bufferDirty) { _buffer_dirty = bufferDirty; }

	void SetTrashBuffer(bool trash) { _trash_window_buffer = trash; 	}

	void SetBitmap(BBitmap *bitmap) { _bitmap = bitmap; }

private:

	/* Event redirection */

    void _MouseMotionEvent(BPoint &where, int32 transit) {

    	if(transit == B_EXITED_VIEW) {

    		/* Change mouse focus */

    		if(_mouse_focused) {

    			_MouseFocusEvent(false);

    		}

    	} else {

    		/* Change mouse focus */

    		if (!_mouse_focused) {

    			_MouseFocusEvent(true);

    		}

    		BMessage msg(BAPP_MOUSE_MOVED);

    		msg.AddInt32("x", (int)where.x);

    		msg.AddInt32("y", (int)where.y);

    		_PostWindowEvent(msg);

    	}

    }

    void _MouseFocusEvent(bool focusGained) {

    	_mouse_focused = focusGained;

    	BMessage msg(BAPP_MOUSE_FOCUS);

    	msg.AddBool("focusGained", focusGained);

    	_PostWindowEvent(msg);

//FIXME: Why were these here?

// if false: be_app->SetCursor(B_HAND_CURSOR);

// if true:  SDL_SetCursor(NULL);

    }

    void _MouseButtonEvent(int32 buttons) {

    	int32 buttonStateChange = buttons ^ _last_buttons;

    	/* Make sure at least one button has changed state */ 

    	if( !(buttonStateChange) ) {

    		return;

    	}

    	/* Add any mouse button events */

    	if(buttonStateChange & B_PRIMARY_MOUSE_BUTTON) {

    		_SendMouseButton(SDL_BUTTON_LEFT, buttons &

    			B_PRIMARY_MOUSE_BUTTON);

    	}

    	if(buttonStateChange & B_SECONDARY_MOUSE_BUTTON) {

    		_SendMouseButton(SDL_BUTTON_RIGHT, buttons &

    			B_PRIMARY_MOUSE_BUTTON);

    	}

    	if(buttonStateChange & B_TERTIARY_MOUSE_BUTTON) {