Mercurial > sdl-ios-xcode
comparison src/video/qtopia/SDL_sysevents.cc @ 1662:782fd950bd46 SDL-1.3
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: */ |