/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997, 1998, 1999, 2000, 2001  Sam Lantinga

    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@devolution.com

*/

/*

    SDL_epocevents.cpp

    Handle the event stream, converting Epoc events into SDL events

    Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi)

*/

#include <stdio.h>

#undef NULL

extern "C" {

//#define DEBUG_TRACE_ENABLED

#include "SDL_error.h"

#include "SDL_video.h"

#include "SDL_keysym.h"

#include "SDL_keyboard.h"

#include "SDL_events_c.h"

#include "SDL_timer.h"

}; /* extern "C" */

#include "SDL_epocvideo.h"

#include "SDL_epocevents_c.h"

#include<linereader.h>

#include<bautils.h>

#include <hal.h>

extern "C" {

/* The translation tables from a console scancode to a SDL keysym */

static SDLKey keymap[MAX_SCANCODE];

static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);

void DisableKeyBlocking(_THIS);

}; /* extern "C" */

TBool isCursorVisible = EFalse;

int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)

{

    int posted = 0;

    SDL_keysym keysym;

//    SDL_TRACE1("hws %d", aWsEvent.Type());

    switch (aWsEvent.Type())

		{    

    case EEventPointer: /* Mouse pointer events */

		{

        const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();

        if(mode == EPointerCursorNone) 

            {

            return 0; //TODO: Find out why events are get despite of cursor should be off

            }

        const TPointerEvent* pointerEvent = aWsEvent.Pointer();

        TPoint mousePos = pointerEvent->iPosition;

        /*!! TODO Pointer do not yet work properly

        //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!!

        if (Private->EPOC_ShrinkedHeight) {

            mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height

        }

        if (Private->EPOC_ShrinkedWidth) {

            mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width

        }

        */

		posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */

		switch (pointerEvent->iType)

			{

        case TPointerEvent::EButton1Down:

            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);

			break;

        case TPointerEvent::EButton1Up:

			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);

			break;

        case TPointerEvent::EButton2Down:

            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);

			break;

		case TPointerEvent::EButton2Up:

			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);

			break;

        case TPointerEvent::EButton3Down:

            posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);

			break;

        case TPointerEvent::EButton3Up:

			posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);

			break;

			} // switch

        break;

	    }

    case EEventKeyDown: /* Key events */

    {

#ifdef SYMBIAN_CRYSTAL

		// special case: 9300/9500 rocker down, simulate left mouse button

		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)

			{

            const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();

            if(mode != EPointerCursorNone) 

                posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);

			}

#endif

       (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);

#ifndef DISABLE_JOYSTICK

        /* Special handling */

        switch((int)keysym.sym) {

        case SDLK_CAPSLOCK:

            if (!isCursorVisible) {

                /* Enable virtual cursor */

	            HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);

            }

            else {

                /* Disable virtual cursor */

                HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);

            }

            isCursorVisible = !isCursorVisible;

            break;

        }

#endif        

	    posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);

        break;

	} 

    case EEventKeyUp: /* Key events */

		{

#ifdef SYMBIAN_CRYSTAL

		// special case: 9300/9500 rocker up, simulate left mouse button

		if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)

			{

            posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);

			}

#endif

	    posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));

        break;

		}

    case EEventFocusGained: /* SDL window got focus */

	    {

        Private->EPOC_IsWindowFocused = ETrue;

		posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);

        /* Draw window background and screen buffer */

        DisableKeyBlocking(_this);  //Markus: guess why:-)

        RedrawWindowL(_this);  

        break;

	    }

    case EEventFocusLost: /* SDL window lost focus */

		{

/*        

        CFbsBitmap* bmp = new (ELeave) CFbsBitmap();

        bmp->Create(Private->EPOC_ScreenSize, Private->EPOC_DisplayMode);

        Private->EPOC_WsScreen->CopyScreenToBitmap(bmp);

        Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow);

        Private->EPOC_WsWindow.BeginRedraw(TRect(Private->EPOC_WsWindow.Size()));

	    Private->EPOC_WindowGc->BitBlt(TPoint(0, 0), bmp);

	    Private->EPOC_WsWindow.EndRedraw();

	    Private->EPOC_WindowGc->Deactivate();

        bmp->Save(_L("C:\\scr.mbm"));

        delete bmp;

*/       

		Private->EPOC_IsWindowFocused = EFalse;

		posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);

        RWsSession s;

        s.Connect();

        RWindowGroup g(s);

        g.Construct(TUint32(&g), EFalse);

        g.EnableReceiptOfFocus(EFalse);

        RWindow w(s);

        w.Construct(g, TUint32(&w));

        w.SetExtent(TPoint(0, 0), Private->EPOC_WsWindow.Size());

        w.SetOrdinalPosition(0);

        w.Activate();

        w.Close();

        g.Close();

        s.Close();

/*

        Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(Private->EPOC_WsWindowGroupID, -1);

        SDL_Delay(500);

        TInt focus = -1;

        while(focus < 0)

            {

            const TInt curr = Private->EPOC_WsSession.GetFocusWindowGroup();

            if(curr != Private->EPOC_WsWindowGroupID)

                focus = curr;

            else

                SDL_Delay(500);

            }

        if(1 < Private->EPOC_WsSession.GetWindowGroupOrdinalPriority(Private->EPOC_WsWindowGroupID))

            {

            Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, -1);

            SDL_Delay(500);

            Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, 0);

            }

*/

        /*//and the request redraw

        TRawEvent redrawEvent;

        redrawEvent.Set(TRawEvent::ERedraw);

        Private->EPOC_WsSession.SimulateRawEvent(redrawEvent);

        Private->EPOC_WsSession.Flush();*/

#if 0

        //!! Not used

        // Wait and eat events until focus is gained again

	    while (ETrue) {

            Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);

            User::WaitForRequest(Private->EPOC_WsEventStatus);

		    Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);

            TInt eventType = Private->EPOC_WsEvent.Type();

		    Private->EPOC_WsEventStatus = KRequestPending;

		    //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);

            if (eventType == EEventFocusGained) {

                RedrawWindowL(_this);

                break;

            }

	    }

#endif

        break;

	    }

    case EEventModifiersChanged: 

    {

	    TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();

        TUint modstate = KMOD_NONE;

        if (modEvent->iModifiers == EModifierLeftShift)

            modstate |= KMOD_LSHIFT;

        if (modEvent->iModifiers == EModifierRightShift)

            modstate |= KMOD_RSHIFT;

        if (modEvent->iModifiers == EModifierLeftCtrl)

            modstate |= KMOD_LCTRL;

        if (modEvent->iModifiers == EModifierRightCtrl)

            modstate |= KMOD_RCTRL;

        if (modEvent->iModifiers == EModifierLeftAlt)

            modstate |= KMOD_LALT;

        if (modEvent->iModifiers == EModifierRightAlt)

            modstate |= KMOD_RALT;

        if (modEvent->iModifiers == EModifierLeftFunc)

            modstate |= KMOD_LMETA;

        if (modEvent->iModifiers == EModifierRightFunc)

            modstate |= KMOD_RMETA;

        if (modEvent->iModifiers == EModifierCapsLock)

            modstate |= KMOD_CAPS;

        SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));

        break;

    }

    default:            

        break;

	} 

    return posted;

}

extern "C" {

void EPOC_PumpEvents(_THIS)

{

    int posted = 0; // !! Do we need this?

    //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);

	while (Private->EPOC_WsEventStatus != KRequestPending) {

		Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);

		posted = EPOC_HandleWsEvent(_this, Private->EPOC_WsEvent);

		Private->EPOC_WsEventStatus = KRequestPending;

		Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);

	}

}

_LIT(KMapFileName, "C:\\sdl_info\\sdlkeymap.cfg");

LOCAL_C void ReadL(RFs& aFs, RArray<TInt>& aArray)

    {

    TInt drive = -1;

    TFileName name(KMapFileName);

    for(TInt i = 'z'; drive < 0 && i >= 'a'; i--)

        {

        name[0] = (TUint16)i;

        if(BaflUtils::FileExists(aFs, name))

            drive = i;

        }

    if(drive < 0)

        return;

    CLineReader* reader = CLineReader::NewLC(aFs, name);

    while(reader->NextL())

        {

        TPtrC ln = reader->Current();

        TLex line(ln);

        TInt n = 0;

        for(;;)

            {

            const TPtrC token = line.NextToken();

            if(token.Length() == 0)

                break;

            if((n & 1) != 0)

                {

                TInt value;

                TLex lex(token);

                User::LeaveIfError(lex.Val(value));

                User::LeaveIfError(aArray.Append(value));

                }

            n++;

            }

        }

    CleanupStack::PopAndDestroy();

    }

void EPOC_InitOSKeymap(_THIS)

{

	int i;

	/* Initialize the key translation table */

	for ( i=0; i<SDL_TABLESIZE(keymap); ++i )

		keymap[i] = SDLK_UNKNOWN;

	/* Numbers */

	for ( i = 0; i<32; ++i ){

		keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);

	}

	/* e.g. Alphabet keys */

	for ( i = 0; i<32; ++i ){

		keymap['A' + i] = (SDLKey)(SDLK_a+i);

	}

	keymap[EStdKeyBackspace]    = SDLK_BACKSPACE;

	keymap[EStdKeyTab]          = SDLK_TAB;

	keymap[EStdKeyEnter]        = SDLK_RETURN;

	keymap[EStdKeyEscape]       = SDLK_ESCAPE;

   	keymap[EStdKeySpace]        = SDLK_SPACE;

   	keymap[EStdKeyPause]        = SDLK_PAUSE;

   	keymap[EStdKeyHome]         = SDLK_HOME;

   	keymap[EStdKeyEnd]          = SDLK_END;

   	keymap[EStdKeyPageUp]       = SDLK_PAGEUP;

   	keymap[EStdKeyPageDown]     = SDLK_PAGEDOWN;

	keymap[EStdKeyDelete]       = SDLK_DELETE;

	keymap[EStdKeyUpArrow]      = SDLK_UP;

	keymap[EStdKeyDownArrow]    = SDLK_DOWN;

	keymap[EStdKeyLeftArrow]    = SDLK_LEFT;

	keymap[EStdKeyRightArrow]   = SDLK_RIGHT;

	keymap[EStdKeyCapsLock]     = SDLK_CAPSLOCK;

	keymap[EStdKeyLeftShift]    = SDLK_LSHIFT;

	keymap[EStdKeyRightShift]   = SDLK_RSHIFT;

	keymap[EStdKeyLeftAlt]      = SDLK_LALT;

	keymap[EStdKeyRightAlt]     = SDLK_RALT;

	keymap[EStdKeyLeftCtrl]     = SDLK_LCTRL;

	keymap[EStdKeyRightCtrl]    = SDLK_RCTRL;

	keymap[EStdKeyLeftFunc]     = SDLK_LMETA;

	keymap[EStdKeyRightFunc]    = SDLK_RMETA;

	keymap[EStdKeyInsert]       = SDLK_INSERT;

	keymap[EStdKeyComma]        = SDLK_COMMA;

	keymap[EStdKeyFullStop]     = SDLK_PERIOD;

	keymap[EStdKeyForwardSlash] = SDLK_SLASH;

	keymap[EStdKeyBackSlash]    = SDLK_BACKSLASH;

	keymap[EStdKeySemiColon]    = SDLK_SEMICOLON;

	keymap[EStdKeySingleQuote]  = SDLK_QUOTE;

	keymap[EStdKeyHash]         = SDLK_HASH;

	keymap[EStdKeySquareBracketLeft]    = SDLK_LEFTBRACKET;

	keymap[EStdKeySquareBracketRight]   = SDLK_RIGHTBRACKET;

	keymap[EStdKeyMinus]        = SDLK_MINUS;

	keymap[EStdKeyEquals]       = SDLK_EQUALS;

   	keymap[EStdKeyF1]          = SDLK_F1;  /* chr + q */

   	keymap[EStdKeyF2]          = SDLK_F2;  /* chr + w */

   	keymap[EStdKeyF3]          = SDLK_F3;  /* chr + e */

   	keymap[EStdKeyF4]          = SDLK_F4;  /* chr + r */

   	keymap[EStdKeyF5]          = SDLK_F5;  /* chr + t */

   	keymap[EStdKeyF6]          = SDLK_F6;  /* chr + y */

   	keymap[EStdKeyF7]          = SDLK_F7;  /* chr + i */

   	keymap[EStdKeyF8]          = SDLK_F8;  /* chr + o */

   	keymap[EStdKeyF9]          = SDLK_F9;  /* chr + a */

   	keymap[EStdKeyF10]         = SDLK_F10; /* chr + s */

   	keymap[EStdKeyF11]         = SDLK_F11; /* chr + d */

   	keymap[EStdKeyF12]         = SDLK_F12; /* chr + f */

	#ifndef SYMBIAN_CRYSTAL 

	//!!7650 additions

    #ifdef __WINS__

   	keymap[EStdKeyXXX]         = SDLK_RETURN;	/* "fire" key */

	#else

   	keymap[EStdKeyDevice3]     = SDLK_RETURN;	/* "fire" key */

	#endif

   	keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK; 

   	keymap[EStdKeyYes]         = SDLK_HOME;		/* "call" key */

   	keymap[EStdKeyNo]		   = SDLK_END;		/* "end call" key */

   	keymap[EStdKeyDevice0]     = SDLK_SPACE;	/* right menu key */

   	keymap[EStdKeyDevice1]     = SDLK_ESCAPE;	/* left menu key */

   	keymap[EStdKeyDevice2]     = SDLK_POWER;	/* power key */

	#endif

 #ifdef SYMBIAN_CRYSTAL 

    keymap[EStdKeyMenu]        = SDLK_ESCAPE;   // menu key

    keymap[EStdKeyDevice6]     = SDLK_LEFT;     // Rocker (joystick) left

    keymap[EStdKeyDevice7]     = SDLK_RIGHT;    // Rocker (joystick) right

    keymap[EStdKeyDevice8]     = SDLK_UP;       // Rocker (joystick) up

    keymap[EStdKeyDevice9]     = SDLK_DOWN;     // Rocker (joystick) down

    keymap[EStdKeyLeftFunc]     = SDLK_LALT;    //chr?

	keymap[EStdKeyRightFunc]    = SDLK_RALT;

    keymap[EStdKeyDeviceA]      = SDLK_RETURN;	/* "fire" key */

#endif

    ///////////////////////////////////////////////////////////

    RFs fs;

    if(KErrNone == fs.Connect())

        {

        RArray<TInt> array;

        TRAPD(err, ReadL(fs, array));

        if(err == KErrNone && array.Count() > 0)

            {

            SDLKey temp[MAX_SCANCODE];

            Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));

            for(TInt k = 0; k < array.Count(); k+= 2)

                {

                const TInt oldval = array[k]; 

                const TInt newval = array[k + 1]; 

                if(oldval >=  0 && oldval < MAX_SCANCODE && newval >=  0 && newval < MAX_SCANCODE)

                    {

                    keymap[oldval] = temp[newval];

                    }

                }

            }

        array.Close();

        }

    fs.Close();

    ///////////////////////////////////////////////////////////

    /* !!TODO

	EStdKeyNumLock=0x1b,

	EStdKeyScrollLock=0x1c,

	EStdKeyNkpForwardSlash=0x84,

	EStdKeyNkpAsterisk=0x85,

	EStdKeyNkpMinus=0x86,

	EStdKeyNkpPlus=0x87,

	EStdKeyNkpEnter=0x88,

	EStdKeyNkp1=0x89,

	EStdKeyNkp2=0x8a,

	EStdKeyNkp3=0x8b,

	EStdKeyNkp4=0x8c,

	EStdKeyNkp5=0x8d,

	EStdKeyNkp6=0x8e,

	EStdKeyNkp7=0x8f,

	EStdKeyNkp8=0x90,

	EStdKeyNkp9=0x91,

	EStdKeyNkp0=0x92,

	EStdKeyNkpFullStop=0x93,

    EStdKeyMenu=0x94,

    EStdKeyBacklightOn=0x95,

    EStdKeyBacklightOff=0x96,

    EStdKeyBacklightToggle=0x97,

    EStdKeyIncContrast=0x98,

    EStdKeyDecContrast=0x99,

    EStdKeySliderDown=0x9a,

    EStdKeySliderUp=0x9b,

    EStdKeyDictaphonePlay=0x9c,

    EStdKeyDictaphoneStop=0x9d,

    EStdKeyDictaphoneRecord=0x9e,

    EStdKeyHelp=0x9f,

    EStdKeyOff=0xa0,

    EStdKeyDial=0xa1,

    EStdKeyIncVolume=0xa2,

    EStdKeyDecVolume=0xa3,

    EStdKeyDevice0=0xa4,

    EStdKeyDevice1=0xa5,

    EStdKeyDevice2=0xa6,

    EStdKeyDevice3=0xa7,

    EStdKeyDevice4=0xa8,

    EStdKeyDevice5=0xa9,

    EStdKeyDevice6=0xaa,

    EStdKeyDevice7=0xab,

    EStdKeyDevice8=0xac,

    EStdKeyDevice9=0xad,

    EStdKeyDeviceA=0xae,

    EStdKeyDeviceB=0xaf,

    EStdKeyDeviceC=0xb0,

    EStdKeyDeviceD=0xb1,

    EStdKeyDeviceE=0xb2,

    EStdKeyDeviceF=0xb3,

    EStdKeyApplication0=0xb4,

    EStdKeyApplication1=0xb5,

    EStdKeyApplication2=0xb6,

    EStdKeyApplication3=0xb7,

    EStdKeyApplication4=0xb8,

    EStdKeyApplication5=0xb9,

    EStdKeyApplication6=0xba,

    EStdKeyApplication7=0xbb,

    EStdKeyApplication8=0xbc,

    EStdKeyApplication9=0xbd,

    EStdKeyApplicationA=0xbe,

    EStdKeyApplicationB=0xbf,