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