| 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 | |