Mercurial > sdl-ios-xcode

comparison src/video/symbian/EKA2/SDL_epocevents.cpp @ 3975:e85e65aec22f SDL-1.2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added S60 port.
author Ryan C. Gordon <icculus@icculus.org>
date Sun, 24 Jun 2007 18:26:35 +0000
parents
children
comparison
equal deleted inserted replaced
3974:42578e98a295 3975:e85e65aec22f
1 #include "epoc_sdl.h"
2
3 #include <stdio.h>
4 #undef NULL
5 extern "C" {
6 //#define DEBUG_TRACE_ENABLED
7 #include "SDL_error.h"
8 #include "SDL_video.h"
9 #include "SDL_keysym.h"
10 #include "SDL_keyboard.h"
11 #include "SDL_events_c.h"
12 #include "SDL_timer.h"
13 } /* extern "C" */
14
15 #include "SDL_epocvideo.h"
16 #include "SDL_epocevents_c.h"
17
18 #include "sdlepocapi.h"
19
20 #include <eikenv.h>
21
22 #include<bautils.h>
23
24
25 extern "C"
26 {
27 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
28 }
29
30 //extern "C" {
31 /* The translation tables from a console scancode to a SDL keysym */
32 static SDLKey keymap[MAX_SCANCODE];
33 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
34 void DisableKeyBlocking(_THIS);
35 //} /* extern "C" */
36
37 SDLKey* KeyMap()
38 {
39 return keymap;
40 }
41
42 TBool isCursorVisible = EFalse;
43
44 void ResetKeyMap()
45 {
46 int i;
47
48 /* Initialize the key translation table */
49 for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
50 keymap[i] = SDLK_UNKNOWN;
51
52
53 /* Numbers */
54 for ( i = 0; i<32; ++i ){
55 keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
56 }
57 /* e.g. Alphabet keys */
58 for ( i = 0; i<32; ++i ){
59 keymap['A' + i] = (SDLKey)(SDLK_a+i);
60 }
61
62 keymap[EStdKeyBackspace] = SDLK_BACKSPACE;
63 keymap[EStdKeyTab] = SDLK_TAB;
64 keymap[EStdKeyEnter] = SDLK_RETURN;
65 keymap[EStdKeyEscape] = SDLK_ESCAPE;
66 keymap[EStdKeySpace] = SDLK_SPACE;
67 keymap[EStdKeyPause] = SDLK_PAUSE;
68 keymap[EStdKeyHome] = SDLK_HOME;
69 keymap[EStdKeyEnd] = SDLK_END;
70 keymap[EStdKeyPageUp] = SDLK_PAGEUP;
71 keymap[EStdKeyPageDown] = SDLK_PAGEDOWN;
72 keymap[EStdKeyDelete] = SDLK_DELETE;
73 keymap[EStdKeyUpArrow] = SDLK_UP;
74 keymap[EStdKeyDownArrow] = SDLK_DOWN;
75 keymap[EStdKeyLeftArrow] = SDLK_LEFT;
76 keymap[EStdKeyRightArrow] = SDLK_RIGHT;
77 keymap[EStdKeyCapsLock] = SDLK_CAPSLOCK;
78 keymap[EStdKeyLeftShift] = SDLK_LSHIFT;
79 keymap[EStdKeyRightShift] = SDLK_RSHIFT;
80 keymap[EStdKeyLeftAlt] = SDLK_LALT;
81 keymap[EStdKeyRightAlt] = SDLK_RALT;
82 keymap[EStdKeyLeftCtrl] = SDLK_LCTRL;
83 keymap[EStdKeyRightCtrl] = SDLK_RCTRL;
84 keymap[EStdKeyLeftFunc] = SDLK_LMETA;
85 keymap[EStdKeyRightFunc] = SDLK_RMETA;
86 keymap[EStdKeyInsert] = SDLK_INSERT;
87 keymap[EStdKeyComma] = SDLK_COMMA;
88 keymap[EStdKeyFullStop] = SDLK_PERIOD;
89 keymap[EStdKeyForwardSlash] = SDLK_SLASH;
90 keymap[EStdKeyBackSlash] = SDLK_BACKSLASH;
91 keymap[EStdKeySemiColon] = SDLK_SEMICOLON;
92 keymap[EStdKeySingleQuote] = SDLK_QUOTE;
93 keymap[EStdKeyHash] = SDLK_HASH;
94 keymap[EStdKeySquareBracketLeft] = SDLK_LEFTBRACKET;
95 keymap[EStdKeySquareBracketRight] = SDLK_RIGHTBRACKET;
96 keymap[EStdKeyMinus] = SDLK_MINUS;
97 keymap[EStdKeyEquals] = SDLK_EQUALS;
98
99 keymap[EStdKeyF1] = SDLK_F1;
100 keymap[EStdKeyF2] = SDLK_F2;
101 keymap[EStdKeyF3] = SDLK_F3;
102 keymap[EStdKeyF4] = SDLK_F4;
103 keymap[EStdKeyF5] = SDLK_F5;
104 keymap[EStdKeyF6] = SDLK_F6;
105 keymap[EStdKeyF7] = SDLK_F7;
106 keymap[EStdKeyF8] = SDLK_F8;
107
108 keymap[EStdKeyF9] = SDLK_F9;
109 keymap[EStdKeyF10] = SDLK_F10;
110 keymap[EStdKeyF11] = SDLK_F11;
111 keymap[EStdKeyF12] = SDLK_F12;
112
113
114 keymap[EStdKeyXXX] = SDLK_RETURN; /* "fire" key */
115
116 keymap[EStdKeyDevice3] = SDLK_RETURN; /* "fire" key */
117 keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
118 keymap[EStdKeyYes] = SDLK_HOME; /* "call" key */
119 keymap[EStdKeyNo] = SDLK_END; /* "end call" key */
120 keymap[EStdKeyDevice0] = SDLK_SPACE; /* right menu key */
121 keymap[EStdKeyDevice1] = SDLK_ESCAPE; /* left menu key */
122 keymap[EStdKeyDevice2] = SDLK_POWER; /* power key */
123
124 keymap[EStdKeyMenu] = SDLK_MENU; // menu key
125 keymap[EStdKeyDevice6] = SDLK_LEFT; // Rocker (joystick) left
126 keymap[EStdKeyDevice7] = SDLK_RIGHT; // Rocker (joystick) right
127 keymap[EStdKeyDevice8] = SDLK_UP; // Rocker (joystick) up
128 keymap[EStdKeyDevice9] = SDLK_DOWN; // Rocker (joystick) down
129 keymap[EStdKeyLeftFunc] = SDLK_LALT; //chr?
130 keymap[EStdKeyRightFunc] = SDLK_RALT;
131 keymap[EStdKeyDeviceA] = SDLK_RETURN; /* "fire" key */
132
133
134
135
136
137 ///////////////////////////////////////////////////////////
138 /*
139 RFs fs;
140 if(KErrNone == fs.Connect())
141 {
142 RArray<TInt> array;
143 TRAPD(err, ReadL(fs, array));
144 if(err == KErrNone && array.Count() > 0)
145 {
146
147 SDLKey temp[MAX_SCANCODE];
148 Mem::Copy(temp, keymap, MAX_SCANCODE * sizeof(SDLKey));
149
150 for(TInt k = 0; k < array.Count(); k+= 2)
151 {
152 const TInt oldval = array[k];
153 const TInt newval = array[k + 1];
154 if(oldval >= 0 && oldval < MAX_SCANCODE && newval >= 0 && newval < MAX_SCANCODE)
155 {
156 keymap[oldval] = temp[newval];
157 }
158 }
159 }
160 array.Close();
161 }
162
163 fs.Close();*/
164 ///////////////////////////////////////////////////////////
165
166
167 keymap[EStdKeyNumLock] = SDLK_NUMLOCK;
168 keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK;
169
170 keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE;
171 keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY;
172 keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS;
173 keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS;
174 keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER;
175 keymap[EStdKeyNkp1] = SDLK_KP1;
176 keymap[EStdKeyNkp2] = SDLK_KP2;
177 keymap[EStdKeyNkp3] = SDLK_KP3;
178 keymap[EStdKeyNkp4] = SDLK_KP4;
179 keymap[EStdKeyNkp5] = SDLK_KP5;
180 keymap[EStdKeyNkp6] = SDLK_KP6;
181 keymap[EStdKeyNkp7] = SDLK_KP7;
182 keymap[EStdKeyNkp8] = SDLK_KP8;
183 keymap[EStdKeyNkp9] = SDLK_KP9;
184 keymap[EStdKeyNkp0] = SDLK_KP0;
185 keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD;
186 /*
187 keymap[EStdKeyMenu] = SDLK_MENU; should be, but not yet
188 keymap[EStdKeyBacklightOn] =
189 keymap[EStdKeyBacklightOff] =
190 keymap[EStdKeyBacklightToggle] =
191 keymap[EStdKeyIncContrast] =
192 keymap[EStdKeyDecContrast] =
193 keymap[EStdKeySliderDown] =
194 keymap[EStdKeySliderUp] =
195 keymap[EStdKeyDictaphonePlay] =
196 keymap[EStdKeyDictaphoneStop] =
197 keymap[EStdKeyDictaphoneRecord] =
198 keymap[EStdKeyHelp] =
199 keymap[EStdKeyOff] =
200 keymap[EStdKeyDial] =
201 keymap[EStdKeyIncVolume] =
202 keymap[EStdKeyDecVolume] =
203 keymap[EStdKeyDevice0] =
204 keymap[EStdKeyDevice1] =
205 keymap[EStdKeyDevice2] =
206 keymap[EStdKeyDevice3] =
207 keymap[EStdKeyDevice4] =
208 keymap[EStdKeyDevice5] =
209 keymap[EStdKeyDevice6] =
210 keymap[EStdKeyDevice7] =
211 keymap[EStdKeyDevice8] =
212 keymap[EStdKeyDevice9] =
213 keymap[EStdKeyDeviceA] =
214 keymap[EStdKeyDeviceB] =
215 keymap[EStdKeyDeviceC] =
216 keymap[EStdKeyDeviceD] =
217 keymap[EStdKeyDeviceE] =
218 keymap[EStdKeyDeviceF] =
219 keymap[EStdKeyApplication0] =
220 keymap[EStdKeyApplication1] =
221 keymap[EStdKeyApplication2] =
222 keymap[EStdKeyApplication3] =
223 keymap[EStdKeyApplication4] =
224 keymap[EStdKeyApplication5] =
225 keymap[EStdKeyApplication6] =
226 keymap[EStdKeyApplication7] =
227 keymap[EStdKeyApplication8] =
228 keymap[EStdKeyApplication9] =
229 keymap[EStdKeyApplicationA] =
230 keymap[EStdKeyApplicationB] =
231 keymap[EStdKeyApplicationC] =
232 keymap[EStdKeyApplicationD] =
233 keymap[EStdKeyApplicationE] =
234 keymap[EStdKeyApplicationF] =
235 keymap[EStdKeyYes] =
236 keymap[EStdKeyNo] =
237 keymap[EStdKeyIncBrightness] =
238 keymap[EStdKeyDecBrightness] =
239 keymap[EStdKeyCaseOpen] =
240 keymap[EStdKeyCaseClose] = */
241
242
243
244 }
245
246
247 int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
248 {
249 int posted = 0;
250 SDL_keysym keysym;
251
252 // SDL_TRACE1("hws %d", aWsEvent.Type());
253
254 switch (aWsEvent.Type())
255 {
256 case EEventPointer: /* Mouse pointer events */
257 {
258 /* const TPointerCursorMode mode = EpocSdlEnv::PointerMode();
259
260
261 if(mode == EPointerCursorNone)
262 {
263 return 0; //TODO: Find out why events are get despite of cursor should be off
264 }
265 */
266 const TPointerEvent* pointerEvent = aWsEvent.Pointer();
267 const TPoint mousePos = EpocSdlEnv::WindowCoordinates(pointerEvent->iPosition);
268
269 /*!! TODO Pointer do not yet work properly
270 //SDL_TRACE1("SDL: EPOC_HandleWsEvent, pointerEvent->iType=%d", pointerEvent->iType); //!!
271
272 if (Private->EPOC_ShrinkedHeight) {
273 mousePos.iY <<= 1; // Scale y coordinate to shrinked screen height
274 }
275 if (Private->EPOC_ShrinkedWidth) {
276 mousePos.iX <<= 1; // Scale x coordinate to shrinked screen width
277 }
278 */
279
280 posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */
281
282 switch (pointerEvent->iType)
283 {
284 case TPointerEvent::EButton1Down:
285 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
286 break;
287 case TPointerEvent::EButton1Up:
288 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
289 break;
290 case TPointerEvent::EButton2Down:
291 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);
292 break;
293 case TPointerEvent::EButton2Up:
294 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);
295 break;
296 case TPointerEvent::EButton3Down:
297 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);
298 break;
299 case TPointerEvent::EButton3Up:
300 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);
301 break;
302 } // switch
303 break;
304 }
305
306 case EEventKeyDown: /* Key events */
307 {
308 #ifdef SYMBIAN_CRYSTAL
309 // special case: 9300/9500 rocker down, simulate left mouse button
310 if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
311 {
312 const TPointerCursorMode mode = Private->EPOC_WsSession.PointerCursorMode();
313 if(mode != EPointerCursorNone)
314 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
315 }
316 #endif
317 (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);
318
319 #ifndef DISABLE_JOYSTICK
320 /* Special handling */
321 switch((int)keysym.sym) {
322 case SDLK_CAPSLOCK:
323 if (!isCursorVisible) {
324 /* Enable virtual cursor */
325 HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
326 }
327 else {
328 /* Disable virtual cursor */
329 HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
330 }
331 isCursorVisible = !isCursorVisible;
332 break;
333 }
334 #endif
335 posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
336 break;
337 }
338
339 case EEventKeyUp: /* Key events */
340 {
341 #ifdef SYMBIAN_CRYSTAL
342 // special case: 9300/9500 rocker up, simulate left mouse button
343 if (aWsEvent.Key()->iScanCode == EStdKeyDeviceA)
344 {
345 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
346 }
347 #endif
348 posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
349 break;
350 }
351
352 case EEventFocusGained: /* SDL window got focus */
353 {
354 Private->iIsWindowFocused = ETrue;
355 posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
356 /* Draw window background and screen buffer */
357 DisableKeyBlocking(_this); //Markus: guess why:-)
358
359 //RedrawWindowL(_this);
360 break;
361 }
362
363 case EEventFocusLost: /* SDL window lost focus */
364 {
365
366 Private->iIsWindowFocused = EFalse;
367
368 posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
369
370
371 break;
372 }
373
374 case EEventModifiersChanged:
375 {
376 TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
377 TUint modstate = KMOD_NONE;
378 if (modEvent->iModifiers == EModifierLeftShift)
379 modstate |= KMOD_LSHIFT;
380 if (modEvent->iModifiers == EModifierRightShift)
381 modstate |= KMOD_RSHIFT;
382 if (modEvent->iModifiers == EModifierLeftCtrl)
383 modstate |= KMOD_LCTRL;
384 if (modEvent->iModifiers == EModifierRightCtrl)
385 modstate |= KMOD_RCTRL;
386 if (modEvent->iModifiers == EModifierLeftAlt)
387 modstate |= KMOD_LALT;
388 if (modEvent->iModifiers == EModifierRightAlt)
389 modstate |= KMOD_RALT;
390 if (modEvent->iModifiers == EModifierLeftFunc)
391 modstate |= KMOD_LMETA;
392 if (modEvent->iModifiers == EModifierRightFunc)
393 modstate |= KMOD_RMETA;
394 if (modEvent->iModifiers == EModifierCapsLock)
395 modstate |= KMOD_CAPS;
396 SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
397 break;
398 }
399 case EEventScreenDeviceChanged:
400 {
401 EpocSdlEnv::WaitDeviceChange();
402 }
403 break;
404 default:
405 break;
406 }
407
408 return posted;
409 }
410
411 extern "C" {
412
413 void EPOC_PumpEvents(_THIS)
414 {
415 MEventQueue& events = EpocSdlEnv::EventQueue();
416 while(events.HasData())
417 {
418 events.Lock();
419
420 //there have to be a copy, so we can release
421 //lock immediately. HandleWsEvent may cause
422 //deadlock otherwise.
423
424 const TWsEvent event = events.Shift();
425 events.Unlock();
426 // const TWsEvent& event = events.Top();
427 EPOC_HandleWsEvent(_this, event);
428 // events.Shift();
429 }
430 }
431
432
433
434 void EPOC_InitOSKeymap(_THIS)
435 {
436 ResetKeyMap();
437 EpocSdlEnv::ObserverEvent(MSDLObserver::EEventKeyMapInit ,0);
438 }
439
440 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
441 {
442 // char debug[256];
443 //SDL_TRACE1("SDL: TranslateKey, scancode=%d", scancode); //!!
444
445 /* Set the keysym information */
446
447 keysym->scancode = scancode;
448
449 if ((scancode >= MAX_SCANCODE) &&
450 ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
451 SDL_SetError("Too big scancode");
452 keysym->scancode = SDLK_UNKNOWN;
453 keysym->mod = KMOD_NONE;
454 return keysym;
455 }
456
457 keysym->mod = SDL_GetModState();
458
459 /* Handle function keys: F1, F2, F3 ... */
460 if (keysym->mod & KMOD_META) {
461 if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
462 switch(scancode) {
463 case 'Q': scancode = EStdKeyF1; break;
464 case 'W': scancode = EStdKeyF2; break;
465 case 'E': scancode = EStdKeyF3; break;
466 case 'R': scancode = EStdKeyF4; break;
467 case 'T': scancode = EStdKeyF5; break;
468 case 'Y': scancode = EStdKeyF6; break;
469 case 'U': scancode = EStdKeyF7; break;
470 case 'I': scancode = EStdKeyF8; break;
471 case 'A': scancode = EStdKeyF9; break;
472 case 'S': scancode = EStdKeyF10; break;
473 case 'D': scancode = EStdKeyF11; break;
474 case 'F': scancode = EStdKeyF12; break;
475 }
476 keysym->sym = keymap[scancode];
477 }
478 }
479
480 if (scancode >= ENonCharacterKeyBase) {
481 // Non character keys
482 keysym->sym = keymap[scancode -
483 ENonCharacterKeyBase + 0x0081]; // !!hard coded
484 } else {
485 keysym->sym = keymap[scancode];
486 }
487
488 /* Remap the arrow keys if the device is rotated */
489 /*
490 if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
491 switch(keysym->sym) {
492 case SDLK_UP: keysym->sym = SDLK_LEFT; break;
493 case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
494 case SDLK_LEFT: keysym->sym = SDLK_DOWN; break;
495 case SDLK_RIGHT:keysym->sym = SDLK_UP; break;
496 }
497 }
498 */
499 /* If UNICODE is on, get the UNICODE value for the key */
500 keysym->unicode = 0;
501
502 #if 0 // !!TODO:unicode
503
504 if ( SDL_TranslateUNICODE )
505 {
506 /* Populate the unicode field with the ASCII value */
507 keysym->unicode = scancode;
508 }
509 #endif
510
511 //!!
512 //sprintf(debug, "SDL: TranslateKey: keysym->scancode=%d, keysym->sym=%d, keysym->mod=%d",
513 // keysym->scancode, keysym->sym, keysym->mod);
514 //SDL_TRACE(debug); //!!
515
516 return(keysym);
517 }
518
519 } /* extern "C" */
520
521