/*
    SDL - Simple DirectMedia Layer
    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002  Sam Lantinga
    Copyright (C) 2001  Hsieh-Fu Tsai

    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
    slouken@libsdl.org
    
    Hsieh-Fu Tsai
    clare@setabox.com
*/

#include "SDL_keysym.h"
#include "SDL_events_c.h"

#include "SDL_nxevents_c.h"
#include "SDL_nximage_c.h"

// The translation tables from a nanox keysym to a SDL keysym
static SDLKey NX_NONASCII_keymap [MWKEY_LAST + 1] ;

void NX_InitOSKeymap (_THIS)
{
    int i ;

    Dprintf ("enter NX_InitOSKeymap\n") ;

    // Map the nanox scancodes to SDL keysyms
    for (i = 0; i < SDL_TABLESIZE (NX_NONASCII_keymap); ++ i)
        NX_NONASCII_keymap [i] = SDLK_UNKNOWN ;

    NX_NONASCII_keymap [MWKEY_LEFT        & 0xFF] = SDLK_LEFT ;
    NX_NONASCII_keymap [MWKEY_RIGHT       & 0xFF] = SDLK_RIGHT ;
    NX_NONASCII_keymap [MWKEY_UP          & 0xFF] = SDLK_UP ;
    NX_NONASCII_keymap [MWKEY_DOWN        & 0xFF] = SDLK_DOWN ;
    NX_NONASCII_keymap [MWKEY_INSERT      & 0xFF] = SDLK_INSERT ;
    NX_NONASCII_keymap [MWKEY_DELETE      & 0xFF] = SDLK_DELETE ;
    NX_NONASCII_keymap [MWKEY_HOME        & 0xFF] = SDLK_HOME ;
    NX_NONASCII_keymap [MWKEY_END         & 0xFF] = SDLK_END ;
    NX_NONASCII_keymap [MWKEY_PAGEUP      & 0xFF] = SDLK_PAGEUP ;
    NX_NONASCII_keymap [MWKEY_PAGEDOWN    & 0xFF] = SDLK_PAGEDOWN ;

    NX_NONASCII_keymap [MWKEY_KP0         & 0xFF] = SDLK_KP0 ;
    NX_NONASCII_keymap [MWKEY_KP1         & 0xFF] = SDLK_KP1 ;
    NX_NONASCII_keymap [MWKEY_KP2         & 0xFF] = SDLK_KP2 ;
    NX_NONASCII_keymap [MWKEY_KP3         & 0xFF] = SDLK_KP3 ;
    NX_NONASCII_keymap [MWKEY_KP4         & 0xFF] = SDLK_KP4 ;
    NX_NONASCII_keymap [MWKEY_KP5         & 0xFF] = SDLK_KP5 ;
    NX_NONASCII_keymap [MWKEY_KP6         & 0xFF] = SDLK_KP6 ;
    NX_NONASCII_keymap [MWKEY_KP7         & 0xFF] = SDLK_KP7 ;
    NX_NONASCII_keymap [MWKEY_KP8         & 0xFF] = SDLK_KP8 ;
    NX_NONASCII_keymap [MWKEY_KP9         & 0xFF] = SDLK_KP9 ;
    NX_NONASCII_keymap [MWKEY_KP_PERIOD   & 0xFF] = SDLK_KP_PERIOD ;
    NX_NONASCII_keymap [MWKEY_KP_DIVIDE   & 0xFF] = SDLK_KP_DIVIDE ;
    NX_NONASCII_keymap [MWKEY_KP_MULTIPLY & 0xFF] = SDLK_KP_MULTIPLY ;
    NX_NONASCII_keymap [MWKEY_KP_MINUS    & 0xFF] = SDLK_KP_MINUS ;
    NX_NONASCII_keymap [MWKEY_KP_PLUS     & 0xFF] = SDLK_KP_PLUS ;
    NX_NONASCII_keymap [MWKEY_KP_ENTER    & 0xFF] = SDLK_KP_ENTER ;
    NX_NONASCII_keymap [MWKEY_KP_EQUALS   & 0xFF] = SDLK_KP_EQUALS ;

    NX_NONASCII_keymap [MWKEY_F1          & 0xFF] = SDLK_F1 ;
    NX_NONASCII_keymap [MWKEY_F2          & 0xFF] = SDLK_F2 ;
    NX_NONASCII_keymap [MWKEY_F3          & 0xFF] = SDLK_F3 ;
    NX_NONASCII_keymap [MWKEY_F4          & 0xFF] = SDLK_F4 ;
    NX_NONASCII_keymap [MWKEY_F5          & 0xFF] = SDLK_F5 ;
    NX_NONASCII_keymap [MWKEY_F6          & 0xFF] = SDLK_F6 ;
    NX_NONASCII_keymap [MWKEY_F7          & 0xFF] = SDLK_F7 ;
    NX_NONASCII_keymap [MWKEY_F8          & 0xFF] = SDLK_F8 ;
    NX_NONASCII_keymap [MWKEY_F9          & 0xFF] = SDLK_F9 ;
    NX_NONASCII_keymap [MWKEY_F10         & 0xFF] = SDLK_F10 ;
    NX_NONASCII_keymap [MWKEY_F11         & 0xFF] = SDLK_F11 ;
    NX_NONASCII_keymap [MWKEY_F12         & 0xFF] = SDLK_F12 ;

    NX_NONASCII_keymap [MWKEY_NUMLOCK     & 0xFF] = SDLK_NUMLOCK ;
    NX_NONASCII_keymap [MWKEY_CAPSLOCK    & 0xFF] = SDLK_CAPSLOCK ;
    NX_NONASCII_keymap [MWKEY_SCROLLOCK   & 0xFF] = SDLK_SCROLLOCK ;
    NX_NONASCII_keymap [MWKEY_LSHIFT      & 0xFF] = SDLK_LSHIFT ;
    NX_NONASCII_keymap [MWKEY_RSHIFT      & 0xFF] = SDLK_RSHIFT ;
    NX_NONASCII_keymap [MWKEY_LCTRL       & 0xFF] = SDLK_LCTRL ;
    NX_NONASCII_keymap [MWKEY_RCTRL       & 0xFF] = SDLK_RCTRL ;
    NX_NONASCII_keymap [MWKEY_LALT        & 0xFF] = SDLK_LALT ;
    NX_NONASCII_keymap [MWKEY_RALT        & 0xFF] = SDLK_RALT ;
    NX_NONASCII_keymap [MWKEY_LMETA       & 0xFF] = SDLK_LMETA ;
    NX_NONASCII_keymap [MWKEY_RMETA       & 0xFF] = SDLK_RMETA ;
    NX_NONASCII_keymap [MWKEY_ALTGR       & 0xFF] = SDLK_MODE ;

    NX_NONASCII_keymap [MWKEY_PRINT       & 0xFF] = SDLK_PRINT ;
    NX_NONASCII_keymap [MWKEY_SYSREQ      & 0xFF] = SDLK_SYSREQ ;
    NX_NONASCII_keymap [MWKEY_PAUSE       & 0xFF] = SDLK_PAUSE ;
    NX_NONASCII_keymap [MWKEY_BREAK       & 0xFF] = SDLK_BREAK ;
    NX_NONASCII_keymap [MWKEY_MENU        & 0xFF] = SDLK_MENU ;

    Dprintf ("leave NX_InitOSKeymap\n") ;
}

SDL_keysym * NX_TranslateKey (GR_EVENT_KEYSTROKE * keystroke, SDL_keysym * keysym)
{
    GR_KEY ch = keystroke -> ch ;

    Dprintf ("enter NX_TranslateKey\n") ;

    keysym -> scancode = keystroke -> scancode ;
    keysym -> sym = SDLK_UNKNOWN ;

    if (ch & MWKEY_NONASCII_MASK) {
        keysym -> sym = NX_NONASCII_keymap [ch & 0xFF] ;
    } else {
        keysym -> sym = ch & 0x7F ;
    }

    keysym -> mod = KMOD_NONE ;
    
#if 1   //   Retrieve more mode information
    {
        GR_KEYMOD   mod = keystroke -> modifiers ;

        if (mod & MWKMOD_LSHIFT)
            keysym -> mod |= KMOD_LSHIFT ;
        if (mod & MWKMOD_RSHIFT)
            keysym -> mod |= KMOD_RSHIFT ;
        if (mod & MWKMOD_LCTRL)
            keysym -> mod |= KMOD_LCTRL ;
        if (mod & MWKMOD_RCTRL)
            keysym -> mod |= KMOD_RCTRL ;
        if (mod & MWKMOD_LALT)
            keysym -> mod |= KMOD_LALT ;
        if (mod & MWKMOD_RALT)
            keysym -> mod |= KMOD_RALT ;
        if (mod & MWKMOD_LMETA)
            keysym -> mod |= KMOD_LMETA ;
        if (mod & MWKMOD_RMETA)
            keysym -> mod |= KMOD_RMETA ;
        if (mod & MWKMOD_NUM)
            keysym -> mod |= KMOD_NUM ;
        if (mod & MWKMOD_CAPS)
            keysym -> mod |= KMOD_CAPS ;
        if (mod & MWKMOD_ALTGR)
            keysym -> mod |= KMOD_MODE ;
    }
#endif

    keysym -> unicode = ch ;

    Dprintf ("leave NX_TranslateKey\n") ;
    return keysym ;
}

static int check_boundary (_THIS, int x, int y)
{
    if (x < OffsetX || y < OffsetY || x > OffsetX + this -> screen -> w ||
        y > OffsetY + this -> screen -> h)
        return 0 ;
            
    return 1 ;
}

void NX_PumpEvents (_THIS)
{
    GR_EVENT         event ;
    static GR_BUTTON last_button_down = 0 ;

    GrCheckNextEvent (& event) ;
    while (event.type != GR_EVENT_TYPE_NONE) {

        // dispatch event
        switch (event.type) {
            case GR_EVENT_TYPE_MOUSE_ENTER :
            {
                Dprintf ("mouse enter\n") ;
                SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS) ;
                break ;
            }

            case GR_EVENT_TYPE_MOUSE_EXIT :
            {
                Dprintf ("mouse exit\n") ;
                SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS) ;
                break ;
            }

            case GR_EVENT_TYPE_FOCUS_IN :
            {
                Dprintf ("focus in\n") ;
                SDL_PrivateAppActive (1, SDL_APPINPUTFOCUS) ;
                break ;
            }

            case GR_EVENT_TYPE_FOCUS_OUT :
            {
                Dprintf ("focus out\n") ;
                SDL_PrivateAppActive (0, SDL_APPINPUTFOCUS) ;
                break ;
            }

            case GR_EVENT_TYPE_MOUSE_MOTION :
            {               
                Dprintf ("mouse motion\n") ;

                if (SDL_VideoSurface) {
                    if (currently_fullscreen) {
                        if (check_boundary (this, event.button.x, event.button.y)) {
                            SDL_PrivateMouseMotion (0, 0, event.button.x - OffsetX, 
                                event.button.y - OffsetY) ;
                        }
                    } else {
                        SDL_PrivateMouseMotion (0, 0, event.button.x, event.button.y) ;
                    }
                }
                break ;
            }

            case GR_EVENT_TYPE_BUTTON_DOWN :
            {
                int button = event.button.buttons ;
                
                Dprintf ("button down\n") ;

                switch (button) {
                    case MWBUTTON_L :
                        button = 1 ;
                        break ;
                    case MWBUTTON_M :
                        button = 2 ;
                        break ;
                    case MWBUTTON_R :
                        button = 3 ;
                        break ;
                    default :
                        button = 0 ;
                }
                last_button_down = button ;
                
                if (currently_fullscreen) {
                    if (check_boundary (this, event.button.x, event.button.y)) {
                        SDL_PrivateMouseButton (SDL_PRESSED, button, 
                            event.button.x - OffsetX, event.button.y - OffsetY) ;
                    }
                } else {
                    SDL_PrivateMouseButton (SDL_PRESSED, button, 
                        event.button.x, event.button.y) ;
                }
                break ;
            }

            // do not konw which button is released
            case GR_EVENT_TYPE_BUTTON_UP :
            {   
                Dprintf ("button up\n") ;

                if (currently_fullscreen) {
                    if (check_boundary (this, event.button.x, event.button.y)) {
                        SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, 
                            event.button.x - OffsetX, event.button.y - OffsetY) ;
                    }
                } else {
                    SDL_PrivateMouseButton (SDL_RELEASED, last_button_down, 
                        event.button.x, event.button.y) ;
                }
                last_button_down = 0 ;
                break ;
            }

            case GR_EVENT_TYPE_KEY_DOWN :
            {
                SDL_keysym keysym ;

                Dprintf ("key down\n") ;
                SDL_PrivateKeyboard (SDL_PRESSED,
                    NX_TranslateKey (& event.keystroke, & keysym)) ;
                break ;
            }

            case GR_EVENT_TYPE_KEY_UP :
            {
                SDL_keysym keysym ;

                Dprintf ("key up\n") ;
                SDL_PrivateKeyboard (SDL_RELEASED,
                    NX_TranslateKey (& event.keystroke, & keysym)) ;
                break ;
            }

            case GR_EVENT_TYPE_CLOSE_REQ :
            {
                Dprintf ("close require\n") ;
                SDL_PrivateQuit () ;
                break ;
            }

            case GR_EVENT_TYPE_EXPOSURE :
            {
                Dprintf ("event_type_exposure\n") ;
                if (SDL_VideoSurface) {
                    NX_RefreshDisplay (this) ;//, & event.exposure) ;
                }
                break ;
            }

            case GR_EVENT_TYPE_UPDATE :
            {
                switch (event.update.utype) {
                    case GR_UPDATE_MAP :
                    {
                        Dprintf ("GR_UPDATE_MAP\n") ;
                        // If we're not active, make ourselves active
                        if (!(SDL_GetAppState () & SDL_APPACTIVE)) {
                            // Send an internal activate event
                            SDL_PrivateAppActive (1, SDL_APPACTIVE) ;
                        }
                        if (SDL_VideoSurface) {
                            NX_RefreshDisplay (this) ;
                        }
                        break ;
                    }
                    
                    case GR_UPDATE_UNMAP :
                    case GR_UPDATE_UNMAPTEMP :
                    {
                        Dprintf ("GR_UPDATE_UNMAP or GR_UPDATE_UNMAPTEMP\n") ;
                        // If we're active, make ourselves inactive
                        if (SDL_GetAppState () & SDL_APPACTIVE) {
                            // Send an internal deactivate event
                            SDL_PrivateAppActive (0, SDL_APPACTIVE | SDL_APPINPUTFOCUS) ;
                        }
                        break ; 
                    }
                    
                    case GR_UPDATE_SIZE :
                    {
                        Dprintf ("GR_UPDATE_SIZE\n") ;
                        SDL_PrivateResize (event.update.width, event.update.height) ;
                        break ; 
                    }
                    
                    default :
                        Dprintf ("unknown GR_EVENT_TYPE_UPDATE\n") ;
                        break ; 
                }
                break ; 
            }
                
            default :
            {
                Dprintf ("pump event default\n") ;
            }
        }

        GrCheckNextEvent (& event) ;
    }
}