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