?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Big cleanup part 1.
[SDL.s60v3.git] / src / video / symbian / SDL_epocevents.cpp
blobf5ac924df4ecc36788bc10a36e169173bad6fb38
1 #include "epoc_sdl.h"
2
3 #include <stdio.h>
4 #undef NULL
5 extern "C" {
6 #include "SDL_error.h"
7 #include "SDL_video.h"
8 #include "SDL_keysym.h"
9 #include "SDL_keyboard.h"
10 #include "SDL_events_c.h"
11 #include "SDL_timer.h"
12 } /* extern "C" */
13
14 #include "SDL_epocvideo.h"
15 #include "SDL_epocevents_c.h"
16
17 #include "sdlepocapi.h"
18
19 #include <eikenv.h>
20
21 #include<bautils.h>
22
23
24 extern "C"
25 {
26 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
27 }
28
29 /* The translation tables from a console scancode to a SDL keysym */
30 static SDLKey keymap[MAX_SCANCODE];
31 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym);
32 void DisableKeyBlocking(_THIS);
33
34 SDLKey* KeyMap()
35 {
36 return keymap;
37 }
38
39 TBool isCursorVisible = EFalse;
40
41 void ResetKeyMap()
42 {
43 int i;
44
45 /* Initialize the key translation table */
46 for ( i=0; i<SDL_TABLESIZE(keymap); ++i )
47 keymap[i] = SDLK_UNKNOWN;
48
49 /* Numbers */
50 for ( i = 0; i<32; ++i ){
51 keymap[' ' + i] = (SDLKey)(SDLK_SPACE+i);
52 }
53 /* e.g. Alphabet keys */
54 for ( i = 0; i<32; ++i ){
55 keymap['A' + i] = (SDLKey)(SDLK_a+i);
56 }
57
58 keymap[EStdKeyBackspace] = SDLK_BACKSPACE;
59 keymap[EStdKeyTab] = SDLK_TAB;
60 keymap[EStdKeyEnter] = SDLK_RETURN;
61 keymap[EStdKeyEscape] = SDLK_ESCAPE;
62 keymap[EStdKeySpace] = SDLK_SPACE;
63 keymap[EStdKeyPause] = SDLK_PAUSE;
64 keymap[EStdKeyHome] = SDLK_HOME;
65 keymap[EStdKeyEnd] = SDLK_END;
66 keymap[EStdKeyPageUp] = SDLK_PAGEUP;
67 keymap[EStdKeyPageDown] = SDLK_PAGEDOWN;
68 keymap[EStdKeyDelete] = SDLK_DELETE;
69 keymap[EStdKeyUpArrow] = SDLK_UP;
70 keymap[EStdKeyDownArrow] = SDLK_DOWN;
71 keymap[EStdKeyLeftArrow] = SDLK_LEFT;
72 keymap[EStdKeyRightArrow] = SDLK_RIGHT;
73 keymap[EStdKeyCapsLock] = SDLK_CAPSLOCK;
74 keymap[EStdKeyLeftShift] = SDLK_LSHIFT;
75 keymap[EStdKeyRightShift] = SDLK_RSHIFT;
76 keymap[EStdKeyLeftAlt] = SDLK_LALT;
77 keymap[EStdKeyRightAlt] = SDLK_RALT;
78 keymap[EStdKeyLeftCtrl] = SDLK_LCTRL;
79 keymap[EStdKeyRightCtrl] = SDLK_RCTRL;
80 keymap[EStdKeyLeftFunc] = SDLK_LMETA;
81 keymap[EStdKeyRightFunc] = SDLK_RMETA;
82 keymap[EStdKeyInsert] = SDLK_INSERT;
83 keymap[EStdKeyComma] = SDLK_COMMA;
84 keymap[EStdKeyFullStop] = SDLK_PERIOD;
85 keymap[EStdKeyForwardSlash] = SDLK_SLASH;
86 keymap[EStdKeyBackSlash] = SDLK_BACKSLASH;
87 keymap[EStdKeySemiColon] = SDLK_SEMICOLON;
88 keymap[EStdKeySingleQuote] = SDLK_QUOTE;
89 keymap[EStdKeyHash] = SDLK_HASH;
90 keymap[EStdKeySquareBracketLeft] = SDLK_LEFTBRACKET;
91 keymap[EStdKeySquareBracketRight] = SDLK_RIGHTBRACKET;
92 keymap[EStdKeyMinus] = SDLK_MINUS;
93 keymap[EStdKeyEquals] = SDLK_EQUALS;
94
95 keymap[EStdKeyF1] = SDLK_F1;
96 keymap[EStdKeyF2] = SDLK_F2;
97 keymap[EStdKeyF3] = SDLK_F3;
98 keymap[EStdKeyF4] = SDLK_F4;
99 keymap[EStdKeyF5] = SDLK_F5;
100 keymap[EStdKeyF6] = SDLK_F6;
101 keymap[EStdKeyF7] = SDLK_F7;
102 keymap[EStdKeyF8] = SDLK_F8;
103
104 keymap[EStdKeyF9] = SDLK_F9;
105 keymap[EStdKeyF10] = SDLK_F10;
106 keymap[EStdKeyF11] = SDLK_F11;
107 keymap[EStdKeyF12] = SDLK_F12;
108
109
110 keymap[EStdKeyXXX] = SDLK_RETURN; /* "fire" key */
111
112 keymap[EStdKeyDevice3] = SDLK_RETURN; /* "fire" key */
113 keymap[EStdKeyNkpAsterisk] = SDLK_ASTERISK;
114 keymap[EStdKeyYes] = SDLK_HOME; /* "call" key */
115 keymap[EStdKeyNo] = SDLK_END; /* "end call" key */
116 keymap[EStdKeyDevice0] = SDLK_SPACE; /* right menu key */
117 keymap[EStdKeyDevice1] = SDLK_ESCAPE; /* left menu key */
118 keymap[EStdKeyDevice2] = SDLK_POWER; /* power key */
119
120 keymap[EStdKeyMenu] = SDLK_MENU; // menu key
121 keymap[EStdKeyDevice6] = SDLK_LEFT; // Rocker (joystick) left
122 keymap[EStdKeyDevice7] = SDLK_RIGHT; // Rocker (joystick) right
123 keymap[EStdKeyDevice8] = SDLK_UP; // Rocker (joystick) up
124 keymap[EStdKeyDevice9] = SDLK_DOWN; // Rocker (joystick) down
125 keymap[EStdKeyLeftFunc] = SDLK_LALT; //chr?
126 keymap[EStdKeyRightFunc] = SDLK_RALT;
127 keymap[EStdKeyDeviceA] = SDLK_RETURN; /* "fire" key */
128
129 keymap[EStdKeyNumLock] = SDLK_NUMLOCK;
130 keymap[EStdKeyScrollLock] = SDLK_SCROLLOCK;
131
132 keymap[EStdKeyNkpForwardSlash] = SDLK_KP_DIVIDE;
133 keymap[EStdKeyNkpAsterisk] = SDLK_KP_MULTIPLY;
134 keymap[EStdKeyNkpMinus] = SDLK_KP_MINUS;
135 keymap[EStdKeyNkpPlus] = SDLK_KP_PLUS;
136 keymap[EStdKeyNkpEnter] = SDLK_KP_ENTER;
137 keymap[EStdKeyNkp1] = SDLK_KP1;
138 keymap[EStdKeyNkp2] = SDLK_KP2;
139 keymap[EStdKeyNkp3] = SDLK_KP3;
140 keymap[EStdKeyNkp4] = SDLK_KP4;
141 keymap[EStdKeyNkp5] = SDLK_KP5;
142 keymap[EStdKeyNkp6] = SDLK_KP6;
143 keymap[EStdKeyNkp7] = SDLK_KP7;
144 keymap[EStdKeyNkp8] = SDLK_KP8;
145 keymap[EStdKeyNkp9] = SDLK_KP9;
146 keymap[EStdKeyNkp0] = SDLK_KP0;
147 keymap[EStdKeyNkpFullStop] = SDLK_KP_PERIOD;
148 }
149
150
151 int EPOC_HandleWsEvent(_THIS, const TWsEvent& aWsEvent)
152 {
153 int posted = 0;
154 SDL_keysym keysym;
155
156 switch (aWsEvent.Type())
157 {
158 case EEventSwitchOff:
159 SDL_PrivateQuit();
160 break;
161
162 case EEventPointer: /* Mouse pointer events */
163 {
164 const TPointerEvent* pointerEvent = aWsEvent.Pointer();
165 const TPoint mousePos = EpocSdlEnv::WindowCoordinates(pointerEvent->iPosition);
166
167 posted += SDL_PrivateMouseMotion(0, 0, mousePos.iX, mousePos.iY); /* Absolute position on screen */
168
169 switch (pointerEvent->iType)
170 {
171 case TPointerEvent::EButton1Down:
172 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_LEFT, 0, 0);
173 break;
174 case TPointerEvent::EButton1Up:
175 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_LEFT, 0, 0);
176 break;
177 case TPointerEvent::EButton2Down:
178 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_RIGHT, 0, 0);
179 break;
180 case TPointerEvent::EButton2Up:
181 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_RIGHT, 0, 0);
182 break;
183 case TPointerEvent::EButton3Down:
184 posted += SDL_PrivateMouseButton(SDL_PRESSED, SDL_BUTTON_MIDDLE, 0, 0);
185 break;
186 case TPointerEvent::EButton3Up:
187 posted += SDL_PrivateMouseButton(SDL_RELEASED, SDL_BUTTON_MIDDLE, 0, 0);
188 break;
189 } // switch
190 break;
191 }
192
193 case EEventKeyDown: /* Key events */
194 {
195 (void*)TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym);
196
197 #ifndef DISABLE_JOYSTICK
198 /* Special handling */
199 switch((int)keysym.sym) {
200 case SDLK_CAPSLOCK:
201 if (!isCursorVisible) {
202 /* Enable virtual cursor */
203 HAL::Set(HAL::EMouseState, HAL::EMouseState_Visible);
204 }
205 else {
206 /* Disable virtual cursor */
207 HAL::Set(HAL::EMouseState, HAL::EMouseState_Invisible);
208 }
209 isCursorVisible = !isCursorVisible;
210 break;
211 }
212 #endif
213 posted += SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
214 break;
215 }
216
217 case EEventKeyUp: /* Key events */
218 {
219 posted += SDL_PrivateKeyboard(SDL_RELEASED, TranslateKey(_this, aWsEvent.Key()->iScanCode, &keysym));
220 break;
221 }
222
223 case EEventFocusGained: /* SDL window got focus */
224 {
225 Private->iIsWindowFocused = ETrue;
226 posted += SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
227 /* Draw window background and screen buffer */
228 DisableKeyBlocking(_this); //Markus: guess why:-)
229
230 //RedrawWindowL(_this);
231 break;
232 }
233
234 case EEventFocusLost: /* SDL window lost focus */
235 {
236
237 Private->iIsWindowFocused = EFalse;
238
239 posted += SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS|SDL_APPMOUSEFOCUS);
240
241
242 break;
243 }
244
245 case EEventModifiersChanged:
246 {
247 TModifiersChangedEvent* modEvent = aWsEvent.ModifiersChanged();
248 TUint modstate = KMOD_NONE;
249 if (modEvent->iModifiers == EModifierLeftShift)
250 modstate |= KMOD_LSHIFT;
251 if (modEvent->iModifiers == EModifierRightShift)
252 modstate |= KMOD_RSHIFT;
253 if (modEvent->iModifiers == EModifierLeftCtrl)
254 modstate |= KMOD_LCTRL;
255 if (modEvent->iModifiers == EModifierRightCtrl)
256 modstate |= KMOD_RCTRL;
257 if (modEvent->iModifiers == EModifierLeftAlt)
258 modstate |= KMOD_LALT;
259 if (modEvent->iModifiers == EModifierRightAlt)
260 modstate |= KMOD_RALT;
261 if (modEvent->iModifiers == EModifierLeftFunc)
262 modstate |= KMOD_LMETA;
263 if (modEvent->iModifiers == EModifierRightFunc)
264 modstate |= KMOD_RMETA;
265 if (modEvent->iModifiers == EModifierCapsLock)
266 modstate |= KMOD_CAPS;
267 SDL_SetModState(STATIC_CAST(SDLMod,(modstate | KMOD_LSHIFT)));
268 break;
269 }
270 case EEventScreenDeviceChanged:
271 {
272 EpocSdlEnv::WaitDeviceChange();
273 }
274 break;
275 default:
276 break;
277 }
278
279 return posted;
280 }
281
282 extern "C" {
283
284 void EPOC_PumpEvents(_THIS)
285 {
286 MEventQueue& events = EpocSdlEnv::EventQueue();
287 while(events.HasData())
288 {
289 events.Lock();
290
291 //there have to be a copy, so we can release
292 //lock immediately. HandleWsEvent may cause
293 //deadlock otherwise.
294
295 const TWsEvent event = events.Shift();
296 events.Unlock();
297 EPOC_HandleWsEvent(_this, event);
298 }
299 }
300
301
302
303 void EPOC_InitOSKeymap(_THIS)
304 {
305 ResetKeyMap();
306 EpocSdlEnv::ObserverEvent(MSDLObserver::EEventKeyMapInit ,0);
307 }
308
309 static SDL_keysym *TranslateKey(_THIS, int scancode, SDL_keysym *keysym)
310 {
311 /* Set the keysym information */
312
313 keysym->scancode = scancode;
314
315 if ((scancode >= MAX_SCANCODE) &&
316 ((scancode - ENonCharacterKeyBase + 0x0081) >= MAX_SCANCODE)) {
317 SDL_SetError("Too big scancode");
318 keysym->scancode = SDLK_UNKNOWN;
319 keysym->mod = KMOD_NONE;
320 return keysym;
321 }
322
323 keysym->mod = SDL_GetModState();
324
325 /* Handle function keys: F1, F2, F3 ... */
326 if (keysym->mod & KMOD_META) {
327 if (scancode >= 'A' && scancode < ('A' + 24)) { /* first 32 alphabet keys */
328 switch(scancode) {
329 case 'Q': scancode = EStdKeyF1; break;
330 case 'W': scancode = EStdKeyF2; break;
331 case 'E': scancode = EStdKeyF3; break;
332 case 'R': scancode = EStdKeyF4; break;
333 case 'T': scancode = EStdKeyF5; break;
334 case 'Y': scancode = EStdKeyF6; break;
335 case 'U': scancode = EStdKeyF7; break;
336 case 'I': scancode = EStdKeyF8; break;
337 case 'A': scancode = EStdKeyF9; break;
338 case 'S': scancode = EStdKeyF10; break;
339 case 'D': scancode = EStdKeyF11; break;
340 case 'F': scancode = EStdKeyF12; break;
341 }
342 keysym->sym = keymap[scancode];
343 }
344 }
345
346 if (scancode >= ENonCharacterKeyBase) {
347 // Non character keys
348 keysym->sym = keymap[scancode -
349 ENonCharacterKeyBase + 0x0081]; // !!hard coded
350 } else {
351 keysym->sym = keymap[scancode];
352 }
353
354 /* Remap the arrow keys if the device is rotated */
355 /*
356 if (Private->EPOC_ScreenOrientation == CFbsBitGc::EGraphicsOrientationRotated270) {
357 switch(keysym->sym) {
358 case SDLK_UP: keysym->sym = SDLK_LEFT; break;
359 case SDLK_DOWN: keysym->sym = SDLK_RIGHT; break;
360 case SDLK_LEFT: keysym->sym = SDLK_DOWN; break;
361 case SDLK_RIGHT:keysym->sym = SDLK_UP; break;
362 }
363 }
364 */
365 /* If UNICODE is on, get the UNICODE value for the key */
366 keysym->unicode = 0;
367
368 return(keysym);
369 }
370
371 } /* extern "C" */
S60v3 port of SDL