/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997-2006 Sam Lantinga

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 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
    Lesser General Public License for more details.

    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
    slouken@libsdl.org
*/

#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>
#if SDL_VIDEO_OPENGL
#include <be/opengl/GLView.h>
#endif
#include <support/UTF8.h>

#include "../../main/beos/SDL_BeApp.h"
#include "SDL_events.h"
#include "SDL_BView.h"

extern "C"
{
#include "../../events/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;
#if SDL_VIDEO_OPENGL
        SDL_GLView = NULL;
#endif
        SDL_View = NULL;
        Unlock();
        shown = false;
        inhibit_resize = false;
    }

    virtual ~ SDL_BWin()
    {
        Lock();
        if (the_view) {
#if SDL_VIDEO_OPENGL
            if (the_view == SDL_GLView) {
                SDL_GLView->UnlockGL();
            }
#endif
            RemoveChild(the_view);
            the_view = NULL;
        }
        Unlock();
#if SDL_VIDEO_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);
    }
    virtual int CreateView(Uint32 flags, Uint32 gl_flags)
    {
        int retval;

        retval = 0;
        Lock();
        if (flags & SDL_INTERNALOPENGL) {
#if SDL_VIDEO_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) {
#if SDL_VIDEO_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)
    {
#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 bool BeginDraw(void)
    {
        return (Lock());
    }
    virtual void DrawAsync(BRect updateRect)
    {
        SDL_View->DrawAsync(updateRect);
    }
    virtual void EndDraw(void)
    {
        SDL_View->Sync();
        Unlock();
    }
#if SDL_VIDEO_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 = 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 */
# 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),
                   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:
#if SDL_VIDEO_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 */
/* vi: set ts=4 sw=4 expandtab: */