src/video/symbian/EKA1/SDL_epocevents.cpp

   1 /*
   2     SDL - Simple DirectMedia Layer
   3     Copyright (C) 1997-2009 Sam Lantinga
   4
   5     This library is free software; you can redistribute it and/or
   6     modify it under the terms of the GNU Library General Public
   7     License as published by the Free Software Foundation; either
   8     version 2 of the License, or (at your option) any later version.
   9
  10     This library is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13     Library General Public License for more details.
  14
  15     You should have received a copy of the GNU Library General Public
  16     License along with this library; if not, write to the Free
  17     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18
  19     Sam Lantinga
  20     slouken@devolution.com
  21 */
  22
  23 /*
  24     SDL_epocevents.cpp
  25     Handle the event stream, converting Epoc events into SDL events
  26
  27     Epoc version by Hannu Viitala (hannu.j.viitala@mbnet.fi)
  28 */
  29
  30
  31 #include <stdio.h>
  32 #undef NULL
  33 extern "C" {
  34 //#define DEBUG_TRACE_ENABLED
  35 #include "SDL_error.h"
  36 #include "SDL_video.h"
  37 #include "SDL_keysym.h"
  38 #include "SDL_keyboard.h"
  39 #include "SDL_events_c.h"
  40 #include "SDL_timer.h"
  41 }; /* extern "C" */
  42
  43 #include "SDL_epocvideo.h"
  44 #include "SDL_epocevents_c.h"
  45
  46 #include<linereader.h>
  47 #include<bautils.h>
  48
  49
  50 #include <hal.h>
  51
  52 extern "C" {
  53 /* The translation tables from a console scancode to a SDL keysym */
  54 static SDLKey keymap[MAX_SCANCODE];
  55 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
  56 void DisableKeyBlocking(_THIS);
  57 }; /* extern "C" */
  58
  59 TBool isCursorVisible = EFalse;
  60
  61 int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
  62 {
  63     int posted = 0;
  64     SDL_keysym keysym;
  65
  66 //    SDL_TRACE1("hws %d", aWsEvent.Type());
  67
  68     switch (aWsEvent.Type())
  69                 {
  70     case EEventPointer: /* Mouse pointer events */
  71                 {
  72
  73         const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();
  74
  75         if(mode == EPointerCursorNone)
  76             {
  77             return 0; //TODO: Find out why events are get despite of cursor should be off
  78             }
  79
  80         const TPointerEvent* pointerEvent = aWsEvent.Pointer();
  81         TPoint mousePos = pointerEvent->iPosition;
  82
  83         /*!! TODO Pointer do not yet work properly
  84         //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!!
  85
  86         if (Private->EPOC_ShrinkedHeight) {
  87             mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height
  88         }
  89         if (Private->EPOC_ShrinkedWidth) {
  90             mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width
  91         }
  92         */
  93
  94                 posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */
  95
  96                 switch (pointerEvent->iType)
  97                         {
  98         case TPointerEvent::EButton1Down:
  99             posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
 100                         break;
 101         case TPointerEvent::EButton1Up:
 102                         posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
 103                         break;
 104         case TPointerEvent::EButton2Down:
 105             posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);
 106                         break;
 107                 case TPointerEvent::EButton2Up:
 108                         posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);
 109                         break;
 110         case TPointerEvent::EButton3Down:
 111             posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);
 112                         break;
 113         case TPointerEvent::EButton3Up:
 114                         posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);
 115                         break;
 116                         } // switch
 117         break;
 118             }
 119
 120     case EEventKeyDown: /* Key events */
 121     {
 122 #ifdef SYMBIAN_CRYSTAL
 123                 // special case: 9300/9500 rocker down, simulate left mouse button
 124                 if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
 125                         {
 126             const TPointerCursorMode mode =  Private->EPOC_WsSession.PointerCursorMode();
 127             if(mode != EPointerCursorNone)
 128                 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
 129                         }
 130 #endif
 131        (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);
 132
 133 #ifndef DISABLE_JOYSTICK
 134         /* Special handling */
 135         switch((int)keysym.sym) {
 136         case SDLK_CAPSLOCK:
 137             if (!isCursorVisible) {
 138                 /* Enable virtual cursor */
 139                     HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
 140             }
 141             else {
 142                 /* Disable virtual cursor */
 143                 HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
 144             }
 145             isCursorVisible = !isCursorVisible;
 146             break;
 147         }
 148 #endif
 149             posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
 150         break;
 151         }
 152
 153     case EEventKeyUp: /* Key events */
 154                 {
 155 #ifdef SYMBIAN_CRYSTAL
 156                 // special case: 9300/9500 rocker up, simulate left mouse button
 157                 if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
 158                         {
 159             posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
 160                         }
 161 #endif
 162             posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
 163         break;
 164                 }
 165
 166     case EEventFocusGained: /* SDL window got focus */
 167             {
 168         Private->EPOC_IsWindowFocused = ETrue;
 169                 posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
 170         /* Draw window background and screen buffer */
 171         DisableKeyBlocking(_this);  //Markus: guess why:-)
 172
 173         RedrawWindowL(_this);
 174         break;
 175             }
 176
 177     case EEventFocusLost: /* SDL window lost focus */
 178                 {
 179 /*
 180         CFbsBitmap* bmp = new (ELeave) CFbsBitmap();
 181         bmp->Create(Private->EPOC_ScreenSize, Private->EPOC_DisplayMode);
 182         Private->EPOC_WsScreen->CopyScreenToBitmap(bmp);
 183         Private->EPOC_WindowGc->Activate(Private->EPOC_WsWindow);
 184         Private->EPOC_WsWindow.BeginRedraw(TRect(Private->EPOC_WsWindow.Size()));
 185             Private->EPOC_WindowGc->BitBlt(TPoint(0, 0), bmp);
 186             Private->EPOC_WsWindow.EndRedraw();
 187             Private->EPOC_WindowGc->Deactivate();
 188         bmp->Save(_L("C:\\scr.mbm"));
 189         delete bmp;
 190 */
 191
 192                 Private->EPOC_IsWindowFocused = EFalse;
 193
 194                 posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
 195
 196         RWsSession s;
 197         s.Connect();
 198         RWindowGroup g(s);
 199         g.Construct(TUint32(&g), EFalse);
 200         g.EnableReceiptOfFocus(EFalse);
 201         RWindow w(s);
 202         w.Construct(g, TUint32(&w));
 203         w.SetExtent(TPoint(0, 0), Private->EPOC_WsWindow.Size());
 204         w.SetOrdinalPosition(0);
 205         w.Activate();
 206         w.Close();
 207         g.Close();
 208         s.Close();
 209
 210 /*
 211         Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(Private->EPOC_WsWindowGroupID, -1);
 212
 213
 214         SDL_Delay(500);
 215         TInt focus = -1;
 216         while(focus < 0)
 217             {
 218             const TInt curr = Private->EPOC_WsSession.GetFocusWindowGroup();
 219             if(curr != Private->EPOC_WsWindowGroupID)
 220                 focus = curr;
 221             else
 222                 SDL_Delay(500);
 223             }
 224
 225         if(1 < Private->EPOC_WsSession.GetWindowGroupOrdinalPriority(Private->EPOC_WsWindowGroupID))
 226             {
 227             Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, -1);
 228             SDL_Delay(500);
 229             Private->EPOC_WsSession.SetWindowGroupOrdinalPosition(focus, 0);
 230             }
 231 */
 232         /*//and the request redraw
 233         TRawEvent redrawEvent;
 234         redrawEvent.Set(TRawEvent::ERedraw);
 235         Private->EPOC_WsSession.SimulateRawEvent(redrawEvent);
 236         Private->EPOC_WsSession.Flush();*/
 237 #if 0
 238         //!! Not used
 239         // Wait and eat events until focus is gained again
 240             while (ETrue) {
 241             Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
 242             User::WaitForRequest(Private->EPOC_WsEventStatus);
 243                     Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);
 244             TInt eventType = Private->EPOC_WsEvent.Type();
 245                     Private->EPOC_WsEventStatus = KRequestPending;
 246                     //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
 247             if (eventType == EEventFocusGained) {
 248                 RedrawWindowL(_this);
 249                 break;
 250             }
 251             }
 252 #endif
 253         break;
 254             }
 255
 256     case EEventModifiersChanged:
 257     {
 258             TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
 259         TUint modstate = KMOD_NONE;
 260         if (modEvent->iModifiers == EModifierLeftShift)
 261             modstate |= KMOD_LSHIFT;
 262         if (modEvent->iModifiers == EModifierRightShift)
 263             modstate |= KMOD_RSHIFT;
 264         if (modEvent->iModifiers == EModifierLeftCtrl)
 265             modstate |= KMOD_LCTRL;
 266         if (modEvent->iModifiers == EModifierRightCtrl)
 267             modstate |= KMOD_RCTRL;
 268         if (modEvent->iModifiers == EModifierLeftAlt)
 269             modstate |= KMOD_LALT;
 270         if (modEvent->iModifiers == EModifierRightAlt)
 271             modstate |= KMOD_RALT;
 272         if (modEvent->iModifiers == EModifierLeftFunc)
 273             modstate |= KMOD_LMETA;
 274         if (modEvent->iModifiers == EModifierRightFunc)
 275             modstate |= KMOD_RMETA;
 276         if (modEvent->iModifiers == EModifierCapsLock)
 277             modstate |= KMOD_CAPS;
 278         SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
 279         break;
 280     }
 281     default:
 282         break;
 283         }
 284
 285     return posted;
 286 }
 287
 288 extern "C" {
 289
 290 void EPOC_PumpEvents(_THIS)
 291 {
 292     int posted = 0; // !! Do we need this?
 293     //Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
 294         while (Private->EPOC_WsEventStatus != KRequestPending) {
 295
 296                 Private->EPOC_WsSession.GetEvent(Private->EPOC_WsEvent);
 297                 posted = EPOC_HandleWsEvent(_this, Private->EPOC_WsEvent);
 298                 Private->EPOC_WsEventStatus = KRequestPending;
 299                 Private->EPOC_WsSession.EventReady(&Private->EPOC_WsEventStatus);
 300         }
 301 }
 302
 303
 304 _LIT(KMapFileName, "C:\\sdl_info\\sdlkeymap.cfg");
 305 LOCAL_C void ReadL(RFs& aFs, RArray<TInt>& aArray)
 306     {
 307     TInt drive = -1;
 308     TFileName name(KMapFileName);
 309     for(TInt i = 'z'; drive < 0 && i >= 'a'; i--)
 310         {
 311         name[0] = (TUint16)i;
 312         if(BaflUtils::FileExists(aFs, name))
 313             drive = i;
 314         }
 315     if(drive < 0)
 316         return;
 317     CLineReader* reader = CLineReader::NewLC(aFs, name);
 318     while(reader->NextL())
 319         {
 320         TPtrC ln = reader->Current();
 321         TLex line(ln);
 322         TInt n = 0;
 323         for(;;)
 324             {
 325             const TPtrC token = line.NextToken();
 326             if(token.Length() == 0)
 327                 break;
 328             if((n & 1) != 0)
 329                 {
 330                 TInt value;
 331                 TLex lex(token);
 332                 User::LeaveIfError(lex.Val(value));
 333                 User::LeaveIfError(aArray.Append(value));
 334                 }
 335             n++;
 336             }
 337         }
 338     CleanupStack::PopAndDestroy();
 339     }
 340
 341
 342 void EPOC_InitOSKeymap(_THIS)
 343 {
 344         int i;
 345
 346         /* Initialize the key translation table */
 347         for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
 348                 keymap[i] = SDLK_UNKNOWN;
 349
 350
 351         /* Numbers */
 352         for ( i = 0; i<32; ++i ){
 353                 keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
 354         }
 355         /* e.g. Alphabet keys */
 356         for ( i = 0; i<32; ++i ){
 357                 keymap['A' + i] = (SDLKey)(SDLK_a+i);
 358         }
 359
 360         keymap[EStdKeyBackspace]    = SDLK_BACKSPACE;
 361         keymap[EStdKeyTab]          = SDLK_TAB;
 362         keymap[EStdKeyEnter]        = SDLK_RETURN;
 363         keymap[EStdKeyEscape]       = SDLK_ESCAPE;
 364         keymap[EStdKeySpace]        = SDLK_SPACE;
 365         keymap[EStdKeyPause]        = SDLK_PAUSE;
 366         keymap[EStdKeyHome]         = SDLK_HOME;
 367         keymap[EStdKeyEnd]          = SDLK_END;
 368         keymap[EStdKeyPageUp]       = SDLK_PAGEUP;
 369         keymap[EStdKeyPageDown]     = SDLK_PAGEDOWN;
 370         keymap[EStdKeyDelete]       = SDLK_DELETE;
 371         keymap[EStdKeyUpArrow]      = SDLK_UP;
 372         keymap[EStdKeyDownArrow]    = SDLK_DOWN;
 373         keymap[EStdKeyLeftArrow]    = SDLK_LEFT;
 374         keymap[EStdKeyRightArrow]   = SDLK_RIGHT;
 375         keymap[EStdKeyCapsLock]     = SDLK_CAPSLOCK;
 376         keymap[EStdKeyLeftShift]    = SDLK_LSHIFT;
 377         keymap[EStdKeyRightShift]   = SDLK_RSHIFT;
 378         keymap[EStdKeyLeftAlt]      = SDLK_LALT;
 379         keymap[EStdKeyRightAlt]     = SDLK_RALT;
 380         keymap[EStdKeyLeftCtrl]     = SDLK_LCTRL;
 381         keymap[EStdKeyRightCtrl]    = SDLK_RCTRL;
 382         keymap[EStdKeyLeftFunc]     = SDLK_LMETA;
 383         keymap[EStdKeyRightFunc]    = SDLK_RMETA;
 384         keymap[EStdKeyInsert]       = SDLK_INSERT;
 385         keymap[EStdKeyComma]        = SDLK_COMMA;
 386         keymap[EStdKeyFullStop]     = SDLK_PERIOD;
 387         keymap[EStdKeyForwardSlash] = SDLK_SLASH;
 388         keymap[EStdKeyBackSlash]    = SDLK_BACKSLASH;
 389         keymap[EStdKeySemiColon]    = SDLK_SEMICOLON;
 390         keymap[EStdKeySingleQuote]  = SDLK_QUOTE;
 391         keymap[EStdKeyHash]         = SDLK_HASH;
 392         keymap[EStdKeySquareBracketLeft]    = SDLK_LEFTBRACKET;
 393         keymap[EStdKeySquareBracketRight]   = SDLK_RIGHTBRACKET;
 394         keymap[EStdKeyMinus]        = SDLK_MINUS;
 395         keymap[EStdKeyEquals]       = SDLK_EQUALS;
 396
 397         keymap[EStdKeyF1]          = SDLK_F1;  /* chr + q */
 398         keymap[EStdKeyF2]          = SDLK_F2;  /* chr + w */
 399         keymap[EStdKeyF3]          = SDLK_F3;  /* chr + e */
 400         keymap[EStdKeyF4]          = SDLK_F4;  /* chr + r */
 401         keymap[EStdKeyF5]          = SDLK_F5;  /* chr + t */
 402         keymap[EStdKeyF6]          = SDLK_F6;  /* chr + y */
 403         keymap[EStdKeyF7]          = SDLK_F7;  /* chr + i */
 404         keymap[EStdKeyF8]          = SDLK_F8;  /* chr + o */
 405
 406         keymap[EStdKeyF9]          = SDLK_F9;  /* chr + a */
 407         keymap[EStdKeyF10]         = SDLK_F10; /* chr + s */
 408         keymap[EStdKeyF11]         = SDLK_F11; /* chr + d */
 409         keymap[EStdKeyF12]         = SDLK_F12; /* chr + f */
 410
 411         #ifndef SYMBIAN_CRYSTAL
 412         //!!7650 additions
 413     #ifdef __WINS__
 414         keymap[EStdKeyXXX]         = SDLK_RETURN;       /* "fire" key */
 415         #else
 416         keymap[EStdKeyDevice3]     = SDLK_RETURN;       /* "fire" key */
 417         #endif
 418         keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
 419         keymap[EStdKeyYes]         = SDLK_HOME;         /* "call" key */
 420         keymap[EStdKeyNo]                  = SDLK_END;          /* "end call" key */
 421         keymap[EStdKeyDevice0]     = SDLK_SPACE;        /* right menu key */
 422         keymap[EStdKeyDevice1]     = SDLK_ESCAPE;       /* left menu key */
 423         keymap[EStdKeyDevice2]     = SDLK_POWER;        /* power key */
 424         #endif
 425
 426  #ifdef SYMBIAN_CRYSTAL
 427     keymap[EStdKeyMenu]        = SDLK_ESCAPE;   // menu key
 428     keymap[EStdKeyDevice6]     = SDLK_LEFT;     // Rocker (joystick) left
 429     keymap[EStdKeyDevice7]     = SDLK_RIGHT;    // Rocker (joystick) right
 430     keymap[EStdKeyDevice8]     = SDLK_UP;       // Rocker (joystick) up
 431     keymap[EStdKeyDevice9]     = SDLK_DOWN;     // Rocker (joystick) down
 432     keymap[EStdKeyLeftFunc]     = SDLK_LALT;    //chr?
 433         keymap[EStdKeyRightFunc]    = SDLK_RALT;
 434     keymap[EStdKeyDeviceA]      = SDLK_RETURN;  /* "fire" key */
 435 #endif
 436
 437     ///////////////////////////////////////////////////////////
 438
 439     RFs fs;
 440     if(KErrNone == fs.Connect())
 441         {
 442         RArray<TInt> array;
 443         TRAPD(err, ReadL(fs, array));
 444         if(err == KErrNone && array.Count() > 0)
 445             {
 446
 447             SDLKey temp[MAX_SCANCODE];
 448             Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
 449
 450             for(TInt k = 0; k < array.Count(); k+= 2)
 451                 {
 452                 const TInt oldval = array[k];
 453                 const TInt newval = array[k + 1];
 454                 if(oldval >=  0 && oldval < MAX_SCANCODE && newval >=  0 && newval < MAX_SCANCODE)
 455                     {
 456                     keymap[oldval] = temp[newval];
 457                     }
 458                 }
 459             }
 460         array.Close();
 461         }
 462
 463     fs.Close();
 464     ///////////////////////////////////////////////////////////
 465
 466     /* !!TODO
 467         EStdKeyNumLock=0x1b,
 468         EStdKeyScrollLock=0x1c,
 469
 470         EStdKeyNkpForwardSlash=0x84,
 471         EStdKeyNkpAsterisk=0x85,
 472         EStdKeyNkpMinus=0x86,
 473         EStdKeyNkpPlus=0x87,
 474         EStdKeyNkpEnter=0x88,
 475         EStdKeyNkp1=0x89,
 476         EStdKeyNkp2=0x8a,
 477         EStdKeyNkp3=0x8b,
 478         EStdKeyNkp4=0x8c,
 479         EStdKeyNkp5=0x8d,
 480         EStdKeyNkp6=0x8e,
 481         EStdKeyNkp7=0x8f,
 482         EStdKeyNkp8=0x90,
 483         EStdKeyNkp9=0x91,
 484         EStdKeyNkp0=0x92,
 485         EStdKeyNkpFullStop=0x93,
 486     EStdKeyMenu=0x94,
 487     EStdKeyBacklightOn=0x95,
 488     EStdKeyBacklightOff=0x96,
 489     EStdKeyBacklightToggle=0x97,
 490     EStdKeyIncContrast=0x98,
 491     EStdKeyDecContrast=0x99,
 492     EStdKeySliderDown=0x9a,
 493     EStdKeySliderUp=0x9b,
 494     EStdKeyDictaphonePlay=0x9c,
 495     EStdKeyDictaphoneStop=0x9d,
 496     EStdKeyDictaphoneRecord=0x9e,
 497     EStdKeyHelp=0x9f,
 498     EStdKeyOff=0xa0,
 499     EStdKeyDial=0xa1,
 500     EStdKeyIncVolume=0xa2,
 501     EStdKeyDecVolume=0xa3,
 502     EStdKeyDevice0=0xa4,
 503     EStdKeyDevice1=0xa5,
 504     EStdKeyDevice2=0xa6,
 505     EStdKeyDevice3=0xa7,
 506     EStdKeyDevice4=0xa8,
 507     EStdKeyDevice5=0xa9,
 508     EStdKeyDevice6=0xaa,
 509     EStdKeyDevice7=0xab,
 510     EStdKeyDevice8=0xac,
 511     EStdKeyDevice9=0xad,
 512     EStdKeyDeviceA=0xae,
 513     EStdKeyDeviceB=0xaf,
 514     EStdKeyDeviceC=0xb0,
 515     EStdKeyDeviceD=0xb1,
 516     EStdKeyDeviceE=0xb2,
 517     EStdKeyDeviceF=0xb3,
 518     EStdKeyApplication0=0xb4,
 519     EStdKeyApplication1=0xb5,
 520     EStdKeyApplication2=0xb6,
 521     EStdKeyApplication3=0xb7,
 522     EStdKeyApplication4=0xb8,
 523     EStdKeyApplication5=0xb9,
 524     EStdKeyApplication6=0xba,
 525     EStdKeyApplication7=0xbb,
 526     EStdKeyApplication8=0xbc,
 527     EStdKeyApplication9=0xbd,
 528     EStdKeyApplicationA=0xbe,
 529     EStdKeyApplicationB=0xbf,
 530     EStdKeyApplicationC=0xc0,
 531     EStdKeyApplicationD=0xc1,
 532     EStdKeyApplicationE=0xc2,
 533     EStdKeyApplicationF=0xc3,
 534     EStdKeyYes=0xc4,
 535     EStdKeyNo=0xc5,
 536     EStdKeyIncBrightness=0xc6,
 537     EStdKeyDecBrightness=0xc7,
 538     EStdKeyCaseOpen=0xc8,
 539     EStdKeyCaseClose=0xc9
 540     */
 541
 542 }
 543
 544
 545
 546 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
 547 {
 548 //    char debug[256];
 549     //SDL_TRACE1("SDL: TranslateKey, scancode=%d", scancode); //!!
 550
 551         /* Set the keysym information */
 552
 553         keysym->scancode = scancode;
 554
 555     if ((scancode >= MAX_SCANCODE) &&
 556         ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
 557         SDL_SetError("Too big scancode");
 558         keysym->scancode = SDLK_UNKNOWN;
 559             keysym->mod = KMOD_NONE;
 560         return keysym;
 561     }
 562
 563         keysym->mod = SDL_GetModState();
 564
 565     /* Handle function keys: F1, F2, F3 ... */
 566     if (keysym->mod & KMOD_META) {
 567         if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
 568             switch(scancode) {
 569                 case 'Q': scancode = EStdKeyF1; break;
 570                 case 'W': scancode = EStdKeyF2; break;
 571                 case 'E': scancode = EStdKeyF3; break;
 572                 case 'R': scancode = EStdKeyF4; break;
 573                 case 'T': scancode = EStdKeyF5; break;
 574                 case 'Y': scancode = EStdKeyF6; break;
 575                 case 'U': scancode = EStdKeyF7; break;
 576                 case 'I': scancode = EStdKeyF8; break;
 577                 case 'A': scancode = EStdKeyF9; break;
 578                 case 'S': scancode = EStdKeyF10; break;
 579                 case 'D': scancode = EStdKeyF11; break;
 580                 case 'F': scancode = EStdKeyF12; break;
 581             }
 582             keysym->sym = keymap[scancode];
 583         }
 584     }
 585
 586     if (scancode >= ENonCharacterKeyBase) {
 587         // Non character keys
 588             keysym->sym = keymap[scancode -
 589             ENonCharacterKeyBase + 0x0081]; // !!hard coded
 590     } else {
 591             keysym->sym = keymap[scancode];
 592     }
 593
 594         /* Remap the arrow keys if the device is rotated */
 595         if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
 596                 switch(keysym->sym) {
 597                         case SDLK_UP:   keysym->sym = SDLK_LEFT;  break;
 598                         case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
 599                         case SDLK_LEFT: keysym->sym = SDLK_DOWN;  break;
 600                         case SDLK_RIGHT:keysym->sym = SDLK_UP;    break;
 601                 }
 602         }
 603
 604         /* If UNICODE is on, get the UNICODE value for the key */
 605         keysym->unicode = 0;
 606
 607 #if 0 // !!TODO:unicode
 608
 609         if ( SDL_TranslateUNICODE )
 610     {
 611                 /* Populate the unicode field with the ASCII value */
 612                 keysym->unicode = scancode;
 613         }
 614 #endif
 615
 616     //!!
 617     //sprintf(debug, "SDL: TranslateKey: keysym->scancode=%d, keysym->sym=%d, keysym->mod=%d",
 618     //    keysym->scancode, keysym->sym, keysym->mod);
 619     //SDL_TRACE(debug); //!!
 620
 621         return(keysym);
 622 }
 623
 624 }; /* extern "C" */
 625
 626