diff options
Diffstat (limited to 'apps/plugins/sdl/src/video/symbian/EKA1/SDL_epocevents.cpp')
-rw-r--r-- | apps/plugins/sdl/src/video/symbian/EKA1/SDL_epocevents.cpp | 626 |
1 files changed, 626 insertions, 0 deletions
diff --git a/apps/plugins/sdl/src/video/symbian/EKA1/SDL_epocevents.cpp b/apps/plugins/sdl/src/video/symbian/EKA1/SDL_epocevents.cpp new file mode 100644 index 0000000000..5ceed5fe3b --- /dev/null +++ b/apps/plugins/sdl/src/video/symbian/EKA1/SDL_epocevents.cpp | |||
@@ -0,0 +1,626 @@ | |||
1 | /* | ||
2 | SDL - Simple DirectMedia Layer | ||
3 | Copyright (C) 1997-2012 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 | |||