src/video/symbian/SDL_epocevents.cpp

   1 #include "epoc_sdl.h"
   2 #include <stdio.h>
   3 #undef NULL
   4 extern "C" {
   5 #include "SDL_error.h"
   6 #include "SDL_video.h"
   7 #include "SDL_keysym.h"
   8 #include "SDL_keyboard.h"
   9 #include "SDL_events_c.h"
  10 #include "SDL_timer.h"
  11 } /* extern "C" */
  12
  13 #include "SDL_epocvideo.h"
  14 #include "SDL_epocevents_c.h"
  15 #include "sdlepocapi.h"
  16 #include <eikenv.h>
  17 #include <bautils.h>
  18
  19 extern "C"
  20 {
  21         static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
  22 }
  23
  24 /* The translation tables from a console scancode to a SDL keysym */
  25 static SDLKey keymap[MAX_SCANCODE];
  26 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
  27
  28 SDLKey* KeyMap()
  29 {
  30         return keymap;
  31 }
  32
  33 void ResetKeyMap()
  34 {
  35         int i;
  36
  37         /* Initialize the key translation table */
  38         for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
  39                 keymap[i] = SDLK_UNKNOWN;
  40
  41         /* Numbers */
  42         for ( i = 0; i<32; ++i ){
  43                 keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
  44         }
  45         /* e.g. Alphabet keys */
  46         for ( i = 0; i<32; ++i ){
  47                 keymap['A' + i] = (SDLKey)(SDLK_a+i);
  48         }
  49
  50         keymap[EStdKeyBackspace]    = SDLK_BACKSPACE;
  51         keymap[EStdKeyTab]          = SDLK_TAB;
  52         keymap[EStdKeyEnter]        = SDLK_RETURN;
  53         keymap[EStdKeyEscape]       = SDLK_ESCAPE;
  54         keymap[EStdKeySpace]        = SDLK_SPACE;
  55         keymap[EStdKeyPause]        = SDLK_PAUSE;
  56         keymap[EStdKeyHome]         = SDLK_HOME;
  57         keymap[EStdKeyEnd]          = SDLK_END;
  58         keymap[EStdKeyPageUp]       = SDLK_PAGEUP;
  59         keymap[EStdKeyPageDown]     = SDLK_PAGEDOWN;
  60         keymap[EStdKeyDelete]       = SDLK_DELETE;
  61         keymap[EStdKeyUpArrow]      = SDLK_UP;
  62         keymap[EStdKeyDownArrow]    = SDLK_DOWN;
  63         keymap[EStdKeyLeftArrow]    = SDLK_LEFT;
  64         keymap[EStdKeyRightArrow]   = SDLK_RIGHT;
  65         keymap[EStdKeyCapsLock]     = SDLK_CAPSLOCK;
  66         keymap[EStdKeyLeftShift]    = SDLK_LSHIFT;
  67         keymap[EStdKeyRightShift]   = SDLK_RSHIFT;
  68         keymap[EStdKeyLeftAlt]      = SDLK_LALT;
  69         keymap[EStdKeyRightAlt]     = SDLK_RALT;
  70         keymap[EStdKeyLeftCtrl]     = SDLK_LCTRL;
  71         keymap[EStdKeyRightCtrl]    = SDLK_RCTRL;
  72         keymap[EStdKeyLeftFunc]     = SDLK_LMETA;
  73         keymap[EStdKeyRightFunc]    = SDLK_RMETA;
  74         keymap[EStdKeyInsert]       = SDLK_INSERT;
  75         keymap[EStdKeyComma]        = SDLK_COMMA;
  76         keymap[EStdKeyFullStop]     = SDLK_PERIOD;
  77         keymap[EStdKeyForwardSlash] = SDLK_SLASH;
  78         keymap[EStdKeyBackSlash]    = SDLK_BACKSLASH;
  79         keymap[EStdKeySemiColon]    = SDLK_SEMICOLON;
  80         keymap[EStdKeySingleQuote]  = SDLK_QUOTE;
  81         keymap[EStdKeyHash]         = SDLK_HASH;
  82         keymap[EStdKeySquareBracketLeft]    = SDLK_LEFTBRACKET;
  83         keymap[EStdKeySquareBracketRight]   = SDLK_RIGHTBRACKET;
  84         keymap[EStdKeyMinus]        = SDLK_MINUS;
  85         keymap[EStdKeyEquals]       = SDLK_EQUALS;
  86
  87         keymap[EStdKeyF1]          = SDLK_F1;
  88         keymap[EStdKeyF2]          = SDLK_F2;
  89         keymap[EStdKeyF3]          = SDLK_F3;
  90         keymap[EStdKeyF4]          = SDLK_F4;
  91         keymap[EStdKeyF5]          = SDLK_F5;
  92         keymap[EStdKeyF6]          = SDLK_F6;
  93         keymap[EStdKeyF7]          = SDLK_F7;
  94         keymap[EStdKeyF8]          = SDLK_F8;
  95
  96         keymap[EStdKeyF9]          = SDLK_F9;
  97         keymap[EStdKeyF10]         = SDLK_F10;
  98         keymap[EStdKeyF11]         = SDLK_F11;
  99         keymap[EStdKeyF12]         = SDLK_F12;
 100
 101         keymap[EStdKeyXXX]         = SDLK_RETURN;       /* "fire" key */
 102
 103         keymap[EStdKeyDevice3]     = SDLK_RETURN;       /* "fire" key */
 104         keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
 105         keymap[EStdKeyYes]         = SDLK_HOME;         /* "call" key */
 106         keymap[EStdKeyNo]                  = SDLK_END;          /* "end call" key */
 107         keymap[EStdKeyDevice0]     = SDLK_SPACE;        /* right menu key */
 108         keymap[EStdKeyDevice1]     = SDLK_ESCAPE;       /* left menu key */
 109         keymap[EStdKeyDevice2]     = SDLK_POWER;        /* power key */
 110
 111         keymap[EStdKeyMenu]        = SDLK_MENU;         // menu key
 112         keymap[EStdKeyDevice6]     = SDLK_LEFT;     // Rocker (joystick) left
 113         keymap[EStdKeyDevice7]     = SDLK_RIGHT;    // Rocker (joystick) right
 114         keymap[EStdKeyDevice8]     = SDLK_UP;       // Rocker (joystick) up
 115         keymap[EStdKeyDevice9]     = SDLK_DOWN;     // Rocker (joystick) down
 116         keymap[EStdKeyLeftFunc]     = SDLK_LALT;    //chr?
 117         keymap[EStdKeyRightFunc]    = SDLK_RALT;
 118         keymap[EStdKeyDeviceA]      = SDLK_RETURN;      /* "fire" key */
 119
 120         keymap[EStdKeyNumLock] = SDLK_NUMLOCK;
 121         keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK;
 122
 123         keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE;
 124         keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY;
 125         keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS;
 126         keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS;
 127         keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER;
 128         keymap[EStdKeyNkp1] = SDLK_KP1;
 129         keymap[EStdKeyNkp2] = SDLK_KP2;
 130         keymap[EStdKeyNkp3] = SDLK_KP3;
 131         keymap[EStdKeyNkp4] = SDLK_KP4;
 132         keymap[EStdKeyNkp5] = SDLK_KP5;
 133         keymap[EStdKeyNkp6] = SDLK_KP6;
 134         keymap[EStdKeyNkp7] = SDLK_KP7;
 135         keymap[EStdKeyNkp8] = SDLK_KP8;
 136         keymap[EStdKeyNkp9] = SDLK_KP9;
 137         keymap[EStdKeyNkp0] = SDLK_KP0;
 138         keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD;
 139
 140         keymap[EStdKeyDecVolume] = SDLK_VOLDOWN;
 141         keymap[EStdKeyIncVolume] = SDLK_VOLUP;
 142 }
 143
 144 int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
 145 {
 146         int posted = 0;
 147         SDL_keysym keysym;
 148
 149         switch (aWsEvent.Type())
 150         {
 151                 case EEventSwitchOff:
 152                         SDL_PrivateQuit();
 153                         break;
 154
 155                 case EEventKeyDown: /* Key events */
 156                         {
 157                                 posted += SDL_PrivateKeyboard(SDL_PRESSED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
 158                                 break;
 159                         }
 160
 161                 case EEventKeyUp: /* Key events */
 162                         {
 163                                 posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
 164                                 break;
 165                         }
 166
 167                 case EEventFocusGained: /* SDL window got focus */
 168                         {
 169                                 Private->iIsWindowFocused = ETrue;
 170                                 posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
 171                                 break;
 172                         }
 173
 174                 case EEventFocusLost: /* SDL window lost focus */
 175                         {
 176                                 Private->iIsWindowFocused = EFalse;
 177                                 posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
 178                                 break;
 179                         }
 180
 181                 case EEventModifiersChanged:
 182                         {
 183                                 TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
 184                                 TUint modstate = KMOD_NONE;
 185                                 if (modEvent->iModifiers == EModifierLeftShift)
 186                                         modstate |= KMOD_LSHIFT;
 187                                 if (modEvent->iModifiers == EModifierRightShift)
 188                                         modstate |= KMOD_RSHIFT;
 189                                 if (modEvent->iModifiers == EModifierLeftCtrl)
 190                                         modstate |= KMOD_LCTRL;
 191                                 if (modEvent->iModifiers == EModifierRightCtrl)
 192                                         modstate |= KMOD_RCTRL;
 193                                 if (modEvent->iModifiers == EModifierLeftAlt)
 194                                         modstate |= KMOD_LALT;
 195                                 if (modEvent->iModifiers == EModifierRightAlt)
 196                                         modstate |= KMOD_RALT;
 197                                 if (modEvent->iModifiers == EModifierLeftFunc)
 198                                         modstate |= KMOD_LMETA;
 199                                 if (modEvent->iModifiers == EModifierRightFunc)
 200                                         modstate |= KMOD_RMETA;
 201                                 if (modEvent->iModifiers == EModifierCapsLock)
 202                                         modstate |= KMOD_CAPS;
 203                                 SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
 204                                 break;
 205                         }
 206
 207                 case EEventScreenDeviceChanged:
 208                         {
 209                                 EpocSdlEnv::WaitDeviceChange();
 210                         }
 211                         break;
 212
 213                 default:
 214                         break;
 215         }
 216
 217         return posted;
 218 }
 219
 220 extern "C" {
 221
 222         void EPOC_PumpEvents(_THIS)
 223         {
 224                 MEventQueue& events = EpocSdlEnv::EventQueue();
 225                 while(events.HasData())
 226                 {
 227                         events.Lock();
 228
 229                         //there have to be a copy, so we can release
 230                         //lock immediately. HandleWsEvent may cause
 231                         //deadlock otherwise.
 232
 233                         const TWsEvent event = events.Shift();
 234                         events.Unlock();
 235                         EPOC_HandleWsEvent(_this, event);
 236                 }
 237         }
 238
 239         void EPOC_InitOSKeymap(_THIS)
 240         {
 241                 ResetKeyMap();
 242                 EpocSdlEnv::ObserverEvent(MSDLObserver::EEventKeyMapInit ,0);
 243         }
 244
 245         static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
 246         {
 247                 /* Set the keysym information */
 248
 249                 keysym->scancode = scancode;
 250
 251                 if ((scancode >= MAX_SCANCODE) &&
 252                                 ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
 253                         SDL_SetError("Too big scancode");
 254                         keysym->scancode = SDLK_UNKNOWN;
 255                         keysym->mod = KMOD_NONE;
 256                         return keysym;
 257                 }
 258
 259                 keysym->mod = SDL_GetModState();
 260
 261                 /* Handle function keys: F1, F2, F3 ... */
 262                 if (keysym->mod & KMOD_META) {
 263                         if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
 264                                 switch(scancode) {
 265                                         case 'Q': scancode = EStdKeyF1; break;
 266                                         case 'W': scancode = EStdKeyF2; break;
 267                                         case 'E': scancode = EStdKeyF3; break;
 268                                         case 'R': scancode = EStdKeyF4; break;
 269                                         case 'T': scancode = EStdKeyF5; break;
 270                                         case 'Y': scancode = EStdKeyF6; break;
 271                                         case 'U': scancode = EStdKeyF7; break;
 272                                         case 'I': scancode = EStdKeyF8; break;
 273                                         case 'A': scancode = EStdKeyF9; break;
 274                                         case 'S': scancode = EStdKeyF10; break;
 275                                         case 'D': scancode = EStdKeyF11; break;
 276                                         case 'F': scancode = EStdKeyF12; break;
 277                                 }
 278                                 keysym->sym = keymap[scancode];
 279                         }
 280                 }
 281
 282                 if (scancode >= ENonCharacterKeyBase) {
 283                         // Non character keys
 284                         keysym->sym = keymap[scancode -
 285                                 ENonCharacterKeyBase + 0x0081]; // !!hard coded
 286                 } else {
 287                         keysym->sym = keymap[scancode];
 288                 }
 289
 290                 /* Remap the arrow keys if the device is rotated */
 291                 /*
 292                    if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
 293                    switch(keysym->sym) {
 294                    case SDLK_UP:        keysym->sym = SDLK_LEFT;  break;
 295                    case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
 296                    case SDLK_LEFT: keysym->sym = SDLK_DOWN;  break;
 297                    case SDLK_RIGHT:keysym->sym = SDLK_UP;    break;
 298                    }
 299                    }
 300                    */
 301                 /* If UNICODE is on, get the UNICODE value for the key */
 302                 keysym->unicode = 0;
 303
 304                 return(keysym);
 305         }
 306
 307 } /* extern "C" */