Mercurial > sdl-ios-xcode

comparison src/video/qtopia/SDL_sysevents.cc @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents 376665398b25
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
29 #include "SDL_events.h" 29 #include "SDL_events.h"
30 #include "SDL_QWin.h" 30 #include "SDL_QWin.h"
31 #include "SDL_lowvideo.h" 31 #include "SDL_lowvideo.h"
32 #include "SDL_timer.h" 32 #include "SDL_timer.h"
33 33
34 extern "C" { 34 extern "C"
35 {
35 #include "../../events/SDL_sysevents.h" 36 #include "../../events/SDL_sysevents.h"
36 #include "../../events/SDL_events_c.h" 37 #include "../../events/SDL_events_c.h"
37 #include "SDL_sysevents_c.h" 38 #include "SDL_sysevents_c.h"
38 39
39 // static SDLKey keymap[128]; 40 // static SDLKey keymap[128];
40 /* This is special because we know it will be run in a loop in a separate 41 /* This is special because we know it will be run in a loop in a separate
41 thread. Normally this function should loop as long as there are input 42 thread. Normally this function should loop as long as there are input
42 states changing, i.e. new events arriving. 43 states changing, i.e. new events arriving.
43 */ 44 */
44 void QT_PumpEvents(_THIS) 45 void QT_PumpEvents (_THIS)
45 { 46 {
46 if(!qApp) { 47 if (!qApp) {
47 return; 48 return;
48 } 49 }
49 // printf("processing events: %p\n", qApp); 50 // printf("processing events: %p\n", qApp);
50 //qApp->processOneEvent(); // wait for a event 51 //qApp->processOneEvent(); // wait for a event
51 qApp->processEvents(); // and process all outstanding ones 52 qApp->processEvents (); // and process all outstanding ones
52 #if 0 53 #if 0
53 BView *view; 54 BView *view;
54 BRect bounds; 55 BRect bounds;
55 BPoint point; 56 BPoint point;
56 uint32 buttons; 57 uint32 buttons;
57 const uint32 button_masks[3] = { 58 const uint32 button_masks[3] = {
58 B_PRIMARY_MOUSE_BUTTON, 59 B_PRIMARY_MOUSE_BUTTON,
59 B_TERTIARY_MOUSE_BUTTON, 60 B_TERTIARY_MOUSE_BUTTON,
60 B_SECONDARY_MOUSE_BUTTON, 61 B_SECONDARY_MOUSE_BUTTON,
61 }; 62 };
62 unsigned int i, j; 63 unsigned int i, j;
63 64
64 /* Check out the mouse buttons and position (slight race condition) */ 65 /* Check out the mouse buttons and position (slight race condition) */
65 if ( SDL_Win->Lock() ) { 66 if (SDL_Win->Lock ()) {
66 /* Don't do anything if we have no view */ 67 /* Don't do anything if we have no view */
67 view = SDL_Win->View(); 68 view = SDL_Win->View ();
68 if ( ! view ) { 69 if (!view) {
69 SDL_Win->Unlock(); 70 SDL_Win->Unlock ();
70 return; 71 return;
71 } 72 }
72 bounds = view->Bounds(); 73 bounds = view->Bounds ();
73 /* Get new input state, if still active */ 74 /* Get new input state, if still active */
74 if ( SDL_Win->IsActive() ) { 75 if (SDL_Win->IsActive ()) {
75 key_flip = !key_flip; 76 key_flip = !key_flip;
76 get_key_info(&keyinfo[key_flip]); 77 get_key_info (&keyinfo[key_flip]);
77 view->GetMouse(&point, &buttons, true); 78 view->GetMouse (&point, &buttons, true);
78 } else { 79 } else {
79 key_flip = key_flip; 80 key_flip = key_flip;
80 point = last_point; 81 point = last_point;
81 buttons = last_buttons; 82 buttons = last_buttons;
82 } 83 }
83 SDL_Win->Unlock(); 84 SDL_Win->Unlock ();
84 } else { 85 } else {
85 return; 86 return;
86 } 87 }
87 88
88 /* If our view is active, we'll find key changes here */ 89 /* If our view is active, we'll find key changes here */
89 if ( SDL_memcmp(keyinfo[0].key_states, keyinfo[1].key_states, 16) != 0 ) { 90 if (SDL_memcmp (keyinfo[0].key_states, keyinfo[1].key_states, 16) !=
90 for ( i=0; i<16; ++i ) { 91 0) {
91 Uint8 new_state, transition; 92 for (i = 0; i < 16; ++i) {
92 93 Uint8 new_state, transition;
93 new_state = keyinfo[key_flip].key_states[i]; 94
94 transition = keyinfo[!key_flip].key_states[i] ^ 95 new_state = keyinfo[key_flip].key_states[i];
95 keyinfo[ key_flip].key_states[i]; 96 transition = keyinfo[!key_flip].key_states[i] ^
96 for ( j=0; j<8; ++j ) { 97 keyinfo[key_flip].key_states[i];
97 if ( transition&0x80 ) 98 for (j = 0; j < 8; ++j) {
98 QueueKey(i*8+j, new_state&0x80); 99 if (transition & 0x80)
99 transition <<= 1; 100 QueueKey (i * 8 + j, new_state & 0x80);
100 new_state <<= 1; 101 transition <<= 1;
101 } 102 new_state <<= 1;
102 } 103 }
103 } 104 }
104 105 }
105 /* We check keyboard, but not mouse if mouse isn't in window */ 106
106 if ( ! bounds.Contains(point) ) { 107 /* We check keyboard, but not mouse if mouse isn't in window */
107 /* Mouse moved outside our view? */ 108 if (!bounds.Contains (point)) {
108 if ( SDL_GetAppState() & SDL_APPMOUSEFOCUS ) { 109 /* Mouse moved outside our view? */
109 SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS); 110 if (SDL_GetAppState () & SDL_APPMOUSEFOCUS) {
110 be_app->SetCursor(B_HAND_CURSOR); 111 SDL_PrivateAppActive (0, SDL_APPMOUSEFOCUS);
111 } 112 be_app->SetCursor (B_HAND_CURSOR);
112 return; 113 }
113 } 114 return;
114 /* Has the mouse moved back into our view? */ 115 }
115 if ( ! (SDL_GetAppState() & SDL_APPMOUSEFOCUS) ) { 116 /* Has the mouse moved back into our view? */
116 /* Reset the B_HAND_CURSOR to our own */ 117 if (!(SDL_GetAppState () & SDL_APPMOUSEFOCUS)) {
117 SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS); 118 /* Reset the B_HAND_CURSOR to our own */
118 SDL_SetCursor(NULL); 119 SDL_PrivateAppActive (1, SDL_APPMOUSEFOCUS);
119 } 120 SDL_SetCursor (NULL);
120 121 }
121 /* Check for mouse motion */ 122
122 if ( point != last_point ) { 123 /* Check for mouse motion */
123 int x, y; 124 if (point != last_point) {
124 125 int x, y;
125 SDL_Win->GetXYOffset(x, y); 126
126 x = (int)point.x - x; 127 SDL_Win->GetXYOffset (x, y);
127 y = (int)point.y - y; 128 x = (int) point.x - x;
128 SDL_PrivateMouseMotion(0, 0, x, y); 129 y = (int) point.y - y;
129 } 130 SDL_PrivateMouseMotion (0, 0, x, y);
130 last_point = point; 131 }
131 132 last_point = point;
132 /* Add any mouse button events */ 133
133 for ( i=0; i<SDL_TABLESIZE(button_masks); ++i ) { 134 /* Add any mouse button events */
134 if ( (buttons ^ last_buttons) & button_masks[i] ) { 135 for (i = 0; i < SDL_TABLESIZE (button_masks); ++i) {
135 if ( buttons & button_masks[i] ) { 136 if ((buttons ^ last_buttons) & button_masks[i]) {
136 SDL_PrivateMouseButton(SDL_PRESSED, 1+i, 0, 0); 137 if (buttons & button_masks[i]) {
137 } else { 138 SDL_PrivateMouseButton (SDL_PRESSED, 1 + i, 0, 0);
138 SDL_PrivateMouseButton(SDL_RELEASED, 1+i, 0, 0); 139 } else {
139 } 140 SDL_PrivateMouseButton (SDL_RELEASED, 1 + i, 0, 0);
140 } 141 }
141 } 142 }
142 last_buttons = buttons; 143 }
144 last_buttons = buttons;
143 #endif 145 #endif
144 } 146 }
145 147
146 void QT_InitOSKeymap(_THIS) 148 void QT_InitOSKeymap (_THIS)
147 { 149 {
148 #if 0 150 #if 0
149 unsigned int i; 151 unsigned int i;
150 152
151 /* Initialize all the key states as "up" */ 153 /* Initialize all the key states as "up" */
152 key_flip = 0; 154 key_flip = 0;
153 SDL_memset(keyinfo[key_flip].key_states, 0, 16); 155 SDL_memset (keyinfo[key_flip].key_states, 0, 16);
154 156
155 /* Initialize the key translation table */ 157 /* Initialize the key translation table */
156 for ( i=0; i<SDL_TABLESIZE(keymap); ++i ) 158 for (i = 0; i < SDL_TABLESIZE (keymap); ++i)
157 keymap[i] = SDLK_UNKNOWN; 159 keymap[i] = SDLK_UNKNOWN;
158 160
159 // keymap[0x01] = SDLK_ESCAPE; 161 // keymap[0x01] = SDLK_ESCAPE;
160 // keymap[B_F1_KEY] = SDLK_F1; 162 // keymap[B_F1_KEY] = SDLK_F1;
161 // keymap[B_F2_KEY] = SDLK_F2; 163 // keymap[B_F2_KEY] = SDLK_F2;
162 // keymap[B_F3_KEY] = SDLK_F3; 164 // keymap[B_F3_KEY] = SDLK_F3;
163 // keymap[B_F4_KEY] = SDLK_F4; 165 // keymap[B_F4_KEY] = SDLK_F4;
164 // keymap[B_F5_KEY] = SDLK_F5; 166 // keymap[B_F5_KEY] = SDLK_F5;
165 // keymap[B_F6_KEY] = SDLK_F6; 167 // keymap[B_F6_KEY] = SDLK_F6;
166 // keymap[B_F7_KEY] = SDLK_F7; 168 // keymap[B_F7_KEY] = SDLK_F7;
167 // keymap[B_F8_KEY] = SDLK_F8; 169 // keymap[B_F8_KEY] = SDLK_F8;
168 // keymap[B_F9_KEY] = SDLK_F9; 170 // keymap[B_F9_KEY] = SDLK_F9;
169 // keymap[B_F10_KEY] = SDLK_F10; 171 // keymap[B_F10_KEY] = SDLK_F10;
170 // keymap[B_F11_KEY] = SDLK_F11; 172 // keymap[B_F11_KEY] = SDLK_F11;
171 // keymap[B_F12_KEY] = SDLK_F12; 173 // keymap[B_F12_KEY] = SDLK_F12;
172 // keymap[B_PRINT_KEY] = SDLK_PRINT; 174 // keymap[B_PRINT_KEY] = SDLK_PRINT;
173 //keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK; 175 //keymap[B_SCROLL_KEY] = SDLK_SCROLLOCK;
174 // keymap[B_PAUSE_KEY] = SDLK_PAUSE; 176 // keymap[B_PAUSE_KEY] = SDLK_PAUSE;
175 keymap[0x11] = SDLK_BACKQUOTE; 177 keymap[0x11] = SDLK_BACKQUOTE;
176 keymap[0x12] = SDLK_1; 178 keymap[0x12] = SDLK_1;
177 keymap[0x13] = SDLK_2; 179 keymap[0x13] = SDLK_2;
178 keymap[0x14] = SDLK_3; 180 keymap[0x14] = SDLK_3;
179 keymap[0x15] = SDLK_4; 181 keymap[0x15] = SDLK_4;
180 keymap[0x16] = SDLK_5; 182 keymap[0x16] = SDLK_5;
181 keymap[0x17] = SDLK_6; 183 keymap[0x17] = SDLK_6;
182 keymap[0x18] = SDLK_7; 184 keymap[0x18] = SDLK_7;
183 keymap[0x19] = SDLK_8; 185 keymap[0x19] = SDLK_8;
184 keymap[0x1a] = SDLK_9; 186 keymap[0x1a] = SDLK_9;
185 keymap[0x1b] = SDLK_0; 187 keymap[0x1b] = SDLK_0;
186 keymap[0x1c] = SDLK_MINUS; 188 keymap[0x1c] = SDLK_MINUS;
187 keymap[0x1d] = SDLK_EQUALS; 189 keymap[0x1d] = SDLK_EQUALS;
188 keymap[0x1e] = SDLK_BACKSPACE; 190 keymap[0x1e] = SDLK_BACKSPACE;
189 keymap[0x1f] = SDLK_INSERT; 191 keymap[0x1f] = SDLK_INSERT;
190 keymap[0x20] = SDLK_HOME; 192 keymap[0x20] = SDLK_HOME;
191 keymap[0x21] = SDLK_PAGEUP; 193 keymap[0x21] = SDLK_PAGEUP;
192 //keymap[0x22] = SDLK_NUMLOCK; 194 //keymap[0x22] = SDLK_NUMLOCK;
193 keymap[0x23] = SDLK_KP_DIVIDE; 195 keymap[0x23] = SDLK_KP_DIVIDE;
194 keymap[0x24] = SDLK_KP_MULTIPLY; 196 keymap[0x24] = SDLK_KP_MULTIPLY;
195 keymap[0x25] = SDLK_KP_MINUS; 197 keymap[0x25] = SDLK_KP_MINUS;
196 keymap[0x26] = SDLK_TAB; 198 keymap[0x26] = SDLK_TAB;
197 keymap[0x27] = SDLK_q; 199 keymap[0x27] = SDLK_q;
198 keymap[0x28] = SDLK_w; 200 keymap[0x28] = SDLK_w;
199 keymap[0x29] = SDLK_e; 201 keymap[0x29] = SDLK_e;
200 keymap[0x2a] = SDLK_r; 202 keymap[0x2a] = SDLK_r;
201 keymap[0x2b] = SDLK_t; 203 keymap[0x2b] = SDLK_t;
202 keymap[0x2c] = SDLK_y; 204 keymap[0x2c] = SDLK_y;
203 keymap[0x2d] = SDLK_u; 205 keymap[0x2d] = SDLK_u;
204 keymap[0x2e] = SDLK_i; 206 keymap[0x2e] = SDLK_i;
205 keymap[0x2f] = SDLK_o; 207 keymap[0x2f] = SDLK_o;
206 keymap[0x30] = SDLK_p; 208 keymap[0x30] = SDLK_p;
207 keymap[0x31] = SDLK_LEFTBRACKET; 209 keymap[0x31] = SDLK_LEFTBRACKET;
208 keymap[0x32] = SDLK_RIGHTBRACKET; 210 keymap[0x32] = SDLK_RIGHTBRACKET;
209 keymap[0x33] = SDLK_BACKSLASH; 211 keymap[0x33] = SDLK_BACKSLASH;
210 keymap[0x34] = SDLK_DELETE; 212 keymap[0x34] = SDLK_DELETE;
211 keymap[0x35] = SDLK_END; 213 keymap[0x35] = SDLK_END;
212 keymap[0x36] = SDLK_PAGEDOWN; 214 keymap[0x36] = SDLK_PAGEDOWN;
213 keymap[0x37] = SDLK_KP7; 215 keymap[0x37] = SDLK_KP7;
214 keymap[0x38] = SDLK_KP8; 216 keymap[0x38] = SDLK_KP8;
215 keymap[0x39] = SDLK_KP9; 217 keymap[0x39] = SDLK_KP9;
216 keymap[0x3a] = SDLK_KP_PLUS; 218 keymap[0x3a] = SDLK_KP_PLUS;
217 //keymap[0x3b] = SDLK_CAPSLOCK; 219 //keymap[0x3b] = SDLK_CAPSLOCK;
218 keymap[0x3c] = SDLK_a; 220 keymap[0x3c] = SDLK_a;
219 keymap[0x3d] = SDLK_s; 221 keymap[0x3d] = SDLK_s;
220 keymap[0x3e] = SDLK_d; 222 keymap[0x3e] = SDLK_d;
221 keymap[0x3f] = SDLK_f; 223 keymap[0x3f] = SDLK_f;
222 keymap[0x40] = SDLK_g; 224 keymap[0x40] = SDLK_g;
223 keymap[0x41] = SDLK_h; 225 keymap[0x41] = SDLK_h;
224 keymap[0x42] = SDLK_j; 226 keymap[0x42] = SDLK_j;
225 keymap[0x43] = SDLK_k; 227 keymap[0x43] = SDLK_k;
226 keymap[0x44] = SDLK_l; 228 keymap[0x44] = SDLK_l;
227 keymap[0x45] = SDLK_SEMICOLON; 229 keymap[0x45] = SDLK_SEMICOLON;
228 keymap[0x46] = SDLK_QUOTE; 230 keymap[0x46] = SDLK_QUOTE;
229 keymap[0x47] = SDLK_RETURN; 231 keymap[0x47] = SDLK_RETURN;
230 keymap[0x48] = SDLK_KP4; 232 keymap[0x48] = SDLK_KP4;
231 keymap[0x49] = SDLK_KP5; 233 keymap[0x49] = SDLK_KP5;
232 keymap[0x4a] = SDLK_KP6; 234 keymap[0x4a] = SDLK_KP6;
233 keymap[0x4b] = SDLK_LSHIFT; 235 keymap[0x4b] = SDLK_LSHIFT;
234 keymap[0x4c] = SDLK_z; 236 keymap[0x4c] = SDLK_z;
235 keymap[0x4d] = SDLK_x; 237 keymap[0x4d] = SDLK_x;
236 keymap[0x4e] = SDLK_c; 238 keymap[0x4e] = SDLK_c;
237 keymap[0x4f] = SDLK_v; 239 keymap[0x4f] = SDLK_v;
238 keymap[0x50] = SDLK_b; 240 keymap[0x50] = SDLK_b;
239 keymap[0x51] = SDLK_n; 241 keymap[0x51] = SDLK_n;
240 keymap[0x52] = SDLK_m; 242 keymap[0x52] = SDLK_m;
241 keymap[0x53] = SDLK_COMMA; 243 keymap[0x53] = SDLK_COMMA;
242 keymap[0x54] = SDLK_PERIOD; 244 keymap[0x54] = SDLK_PERIOD;
243 keymap[0x55] = SDLK_SLASH; 245 keymap[0x55] = SDLK_SLASH;
244 keymap[0x56] = SDLK_RSHIFT; 246 keymap[0x56] = SDLK_RSHIFT;
245 keymap[0x57] = SDLK_UP; 247 keymap[0x57] = SDLK_UP;
246 keymap[0x58] = SDLK_KP1; 248 keymap[0x58] = SDLK_KP1;
247 keymap[0x59] = SDLK_KP2; 249 keymap[0x59] = SDLK_KP2;
248 keymap[0x5a] = SDLK_KP3; 250 keymap[0x5a] = SDLK_KP3;
249 keymap[0x5b] = SDLK_KP_ENTER; 251 keymap[0x5b] = SDLK_KP_ENTER;
250 //keymap[0x5c] = SDLK_LCTRL; 252 //keymap[0x5c] = SDLK_LCTRL;
251 //keymap[0x5d] = SDLK_LALT; 253 //keymap[0x5d] = SDLK_LALT;
252 keymap[0x5e] = SDLK_SPACE; 254 keymap[0x5e] = SDLK_SPACE;
253 //keymap[0x5f] = SDLK_RALT; 255 //keymap[0x5f] = SDLK_RALT;
254 //keymap[0x60] = SDLK_RCTRL; 256 //keymap[0x60] = SDLK_RCTRL;
255 keymap[0x61] = SDLK_LEFT; 257 keymap[0x61] = SDLK_LEFT;
256 keymap[0x62] = SDLK_DOWN; 258 keymap[0x62] = SDLK_DOWN;
257 keymap[0x63] = SDLK_RIGHT; 259 keymap[0x63] = SDLK_RIGHT;
258 keymap[0x64] = SDLK_KP0; 260 keymap[0x64] = SDLK_KP0;
259 keymap[0x65] = SDLK_KP_PERIOD; 261 keymap[0x65] = SDLK_KP_PERIOD;
260 //keymap[0x66] = SDLK_LMETA; 262 //keymap[0x66] = SDLK_LMETA;
261 //keymap[0x67] = SDLK_RMETA; 263 //keymap[0x67] = SDLK_RMETA;
262 //keymap[0x68] = SDLK_MENU; 264 //keymap[0x68] = SDLK_MENU;
263 keymap[0x69] = SDLK_EURO; 265 keymap[0x69] = SDLK_EURO;
264 keymap[0x6a] = SDLK_KP_EQUALS; 266 keymap[0x6a] = SDLK_KP_EQUALS;
265 keymap[0x6b] = SDLK_POWER; 267 keymap[0x6b] = SDLK_POWER;
266 #endif 268 #endif
267 } 269 }
268 270
269 }; /* Extern C */ 271 }; /* Extern C */
272
273 /* vi: set ts=4 sw=4 expandtab: */