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