{

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;

{

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

}

{

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

{

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,

EStdKeyApplicationC=0xc0,

EStdKeyApplicationD=0xc1,

EStdKeyApplicationE=0xc2,

EStdKeyApplicationF=0xc3,

EStdKeyYes=0xc4,

EStdKeyNo=0xc5,

EStdKeyIncBrightness=0xc6,

EStdKeyDecBrightness=0xc7,

EStdKeyCaseOpen=0xc8,

EStdKeyCaseClose=0xc9

*/