| #include "epoc_sdl.h" |
| |
| #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 "sdlepocapi.h" |
| |
| #include <eikenv.h> |
| |
| #include<bautils.h> |
| |
| |
| extern "C" |
| { |
| static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym); |
| } |
| |
| //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" */ |
| |
| SDLKey* KeyMap() |
| { |
| return keymap; |
| } |
| |
| TBool isCursorVisible = EFalse; |
| |
| void ResetKeyMap() |
| { |
| 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; |
| keymap[EStdKeyF2] = SDLK_F2; |
| keymap[EStdKeyF3] = SDLK_F3; |
| keymap[EStdKeyF4] = SDLK_F4; |
| keymap[EStdKeyF5] = SDLK_F5; |
| keymap[EStdKeyF6] = SDLK_F6; |
| keymap[EStdKeyF7] = SDLK_F7; |
| keymap[EStdKeyF8] = SDLK_F8; |
| |
| keymap[EStdKeyF9] = SDLK_F9; |
| keymap[EStdKeyF10] = SDLK_F10; |
| keymap[EStdKeyF11] = SDLK_F11; |
| keymap[EStdKeyF12] = SDLK_F12; |
| |
| |
| keymap[EStdKeyXXX] = SDLK_RETURN; /* "fire" key */ |
| |
| keymap[EStdKeyDevice3] = SDLK_RETURN; /* "fire" key */ |
| 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 */ |
| |
| keymap[EStdKeyMenu] = SDLK_MENU; // 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 */ |
| |
| |
| |
| |
| |
| /////////////////////////////////////////////////////////// |
| /* |
| 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();*/ |
| /////////////////////////////////////////////////////////// |
| |
| |
| keymap[EStdKeyNumLock] = SDLK_NUMLOCK; |
| keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK; |
| |
| keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE; |
| keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY; |
| keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS; |
| keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS; |
| keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER; |
| keymap[EStdKeyNkp1] = SDLK_KP1; |
| keymap[EStdKeyNkp2] = SDLK_KP2; |
| keymap[EStdKeyNkp3] = SDLK_KP3; |
| keymap[EStdKeyNkp4] = SDLK_KP4; |
| keymap[EStdKeyNkp5] = SDLK_KP5; |
| keymap[EStdKeyNkp6] = SDLK_KP6; |
| keymap[EStdKeyNkp7] = SDLK_KP7; |
| keymap[EStdKeyNkp8] = SDLK_KP8; |
| keymap[EStdKeyNkp9] = SDLK_KP9; |
| keymap[EStdKeyNkp0] = SDLK_KP0; |
| keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD; |
| /* |
| keymap[EStdKeyMenu] = SDLK_MENU; should be, but not yet |
| keymap[EStdKeyBacklightOn] = |
| keymap[EStdKeyBacklightOff] = |
| keymap[EStdKeyBacklightToggle] = |
| keymap[EStdKeyIncContrast] = |
| keymap[EStdKeyDecContrast] = |
| keymap[EStdKeySliderDown] = |
| keymap[EStdKeySliderUp] = |
| keymap[EStdKeyDictaphonePlay] = |
| keymap[EStdKeyDictaphoneStop] = |
| keymap[EStdKeyDictaphoneRecord] = |
| keymap[EStdKeyHelp] = |
| keymap[EStdKeyOff] = |
| keymap[EStdKeyDial] = |
| keymap[EStdKeyIncVolume] = |
| keymap[EStdKeyDecVolume] = |
| keymap[EStdKeyDevice0] = |
| keymap[EStdKeyDevice1] = |
| keymap[EStdKeyDevice2] = |
| keymap[EStdKeyDevice3] = |
| keymap[EStdKeyDevice4] = |
| keymap[EStdKeyDevice5] = |
| keymap[EStdKeyDevice6] = |
| keymap[EStdKeyDevice7] = |
| keymap[EStdKeyDevice8] = |
| keymap[EStdKeyDevice9] = |
| keymap[EStdKeyDeviceA] = |
| keymap[EStdKeyDeviceB] = |
| keymap[EStdKeyDeviceC] = |
| keymap[EStdKeyDeviceD] = |
| keymap[EStdKeyDeviceE] = |
| keymap[EStdKeyDeviceF] = |
| keymap[EStdKeyApplication0] = |
| keymap[EStdKeyApplication1] = |
| keymap[EStdKeyApplication2] = |
| keymap[EStdKeyApplication3] = |
| keymap[EStdKeyApplication4] = |
| keymap[EStdKeyApplication5] = |
| keymap[EStdKeyApplication6] = |
| keymap[EStdKeyApplication7] = |
| keymap[EStdKeyApplication8] = |
| keymap[EStdKeyApplication9] = |
| keymap[EStdKeyApplicationA] = |
| keymap[EStdKeyApplicationB] = |
| keymap[EStdKeyApplicationC] = |
| keymap[EStdKeyApplicationD] = |
| keymap[EStdKeyApplicationE] = |
| keymap[EStdKeyApplicationF] = |
| keymap[EStdKeyYes] = |
| keymap[EStdKeyNo] = |
| keymap[EStdKeyIncBrightness] = |
| keymap[EStdKeyDecBrightness] = |
| keymap[EStdKeyCaseOpen] = |
| keymap[EStdKeyCaseClose] = */ |
| |
| |
| |
| } |
| |
| |
| 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 = EpocSdlEnv::PointerMode(); |
| |
| |
| if(mode == EPointerCursorNone) |
| { |
| return 0; //TODO: Find out why events are get despite of cursor should be off |
| } |
| */ |
| const TPointerEvent* pointerEvent = aWsEvent.Pointer(); |
| const TPoint mousePos = EpocSdlEnv::WindowCoordinates(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->iIsWindowFocused = 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 */ |
| { |
| |
| Private->iIsWindowFocused = EFalse; |
| |
| posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS); |
| |
| |
| 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; |
| } |
| case EEventScreenDeviceChanged: |
| { |
| EpocSdlEnv::WaitDeviceChange(); |
| } |
| break; |
| default: |
| break; |
| } |
| |
| return posted; |
| } |
| |
| extern "C" { |
| |
| void EPOC_PumpEvents(_THIS) |
| { |
| MEventQueue& events = EpocSdlEnv::EventQueue(); |
| while(events.HasData()) |
| { |
| events.Lock(); |
| |
| //there have to be a copy, so we can release |
| //lock immediately. HandleWsEvent may cause |
| //deadlock otherwise. |
| |
| const TWsEvent event = events.Shift(); |
| events.Unlock(); |
| // const TWsEvent& event = events.Top(); |
| EPOC_HandleWsEvent(_this, event); |
| // events.Shift(); |
| } |
| } |
| |
| |
| |
| void EPOC_InitOSKeymap(_THIS) |
| { |
| ResetKeyMap(); |
| EpocSdlEnv::ObserverEvent(MSDLObserver::EEventKeyMapInit ,0); |
| } |
| |
| static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym) |
| { |
| // char debug[256]; |
| //SDL_TRACE1("SDL: TranslateKey, scancode=%d", scancode); //!! |
| |
| /* Set the keysym information */ |
| |
| keysym->scancode = scancode; |
| |
| if ((scancode >= MAX_SCANCODE) && |
| ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) { |
| SDL_SetError("Too big scancode"); |
| keysym->scancode = SDLK_UNKNOWN; |
| keysym->mod = KMOD_NONE; |
| return keysym; |
| } |
| |
| keysym->mod = SDL_GetModState(); |
| |
| /* Handle function keys: F1, F2, F3 ... */ |
| if (keysym->mod & KMOD_META) { |
| if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */ |
| switch(scancode) { |
| case 'Q': scancode = EStdKeyF1; break; |
| case 'W': scancode = EStdKeyF2; break; |
| case 'E': scancode = EStdKeyF3; break; |
| case 'R': scancode = EStdKeyF4; break; |
| case 'T': scancode = EStdKeyF5; break; |
| case 'Y': scancode = EStdKeyF6; break; |
| case 'U': scancode = EStdKeyF7; break; |
| case 'I': scancode = EStdKeyF8; break; |
| case 'A': scancode = EStdKeyF9; break; |
| case 'S': scancode = EStdKeyF10; break; |
| case 'D': scancode = EStdKeyF11; break; |
| case 'F': scancode = EStdKeyF12; break; |
| } |
| keysym->sym = keymap[scancode]; |
| } |
| } |
| |
| if (scancode >= ENonCharacterKeyBase) { |
| // Non character keys |
| keysym->sym = keymap[scancode - |
| ENonCharacterKeyBase + 0x0081]; // !!hard coded |
| } else { |
| keysym->sym = keymap[scancode]; |
| } |
| |
| /* Remap the arrow keys if the device is rotated */ |
| /* |
| if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) { |
| switch(keysym->sym) { |
| case SDLK_UP: keysym->sym = SDLK_LEFT; break; |
| case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break; |
| case SDLK_LEFT: keysym->sym = SDLK_DOWN; break; |
| case SDLK_RIGHT:keysym->sym = SDLK_UP; break; |
| } |
| } |
| */ |
| /* If UNICODE is on, get the UNICODE value for the key */ |
| keysym->unicode = 0; |
| |
| #if 0 // !!TODO:unicode |
| |
| if ( SDL_TranslateUNICODE ) |
| { |
| /* Populate the unicode field with the ASCII value */ |
| keysym->unicode = scancode; |
| } |
| #endif |
| |
| //!! |
| //sprintf(debug, "SDL: TranslateKey: keysym->scancode=%d, keysym->sym=%d, keysym->mod=%d", |
| // keysym->scancode, keysym->sym, keysym->mod); |
| //SDL_TRACE(debug); //!! |
| |
| return(keysym); |
| } |
| |
| } /* extern "C" */ |
| |
| |
