/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2004 Sam Lantinga

    Copyright (C) 2001  Hsieh-Fu Tsai

    Copyright (C) 2002  Greg Haerr <greg@censoft.com>

    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_config.h"

#include "SDL_keysym.h"

#include "../../events/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_arraysize (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 ; 

                    }

                    case GR_UPDATE_MOVE :

		    case GR_UPDATE_REPARENT :

                    {

                        Dprintf ("GR_UPDATE_MOVE or GR_UPDATE_REPARENT\n") ;

#ifdef ENABLE_NANOX_DIRECT_FB

			if (Clientfb) {

			    /* Get current window position and fb pointer*/

			    if (currently_fullscreen) 

				GrGetWindowFBInfo(FSwindow, &fbinfo);

			    else

				GrGetWindowFBInfo(SDL_Window, &fbinfo);

			}

#endif

                        break ; 

                    }

                    default :

                        Dprintf ("unknown GR_EVENT_TYPE_UPDATE\n") ;

                        break ; 

                }

                break ; 

            }

            default :

            {

                Dprintf ("pump event default\n") ;

            }

        }

        GrCheckNextEvent (& event) ;

    }

}