diff options
author | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
---|---|---|
committer | David Walter Seikel | 2013-01-13 17:29:19 +1000 |
commit | 07274513e984f0b5544586c74508ccd16e7dcafa (patch) | |
tree | b32ff2a9136fbc1a4a6a0ed1e4d79cde0f5f16d9 /libraries/ecore/src/lib/ecore_win32/ecore_win32_event.c | |
parent | Added Irrlicht 1.8, but without all the Windows binaries. (diff) | |
download | SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.zip SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.gz SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.bz2 SledjHamr-07274513e984f0b5544586c74508ccd16e7dcafa.tar.xz |
Remove EFL, since it's been released now.
Diffstat (limited to '')
-rw-r--r-- | libraries/ecore/src/lib/ecore_win32/ecore_win32_event.c | 1295 |
1 files changed, 0 insertions, 1295 deletions
diff --git a/libraries/ecore/src/lib/ecore_win32/ecore_win32_event.c b/libraries/ecore/src/lib/ecore_win32/ecore_win32_event.c deleted file mode 100644 index 388776c..0000000 --- a/libraries/ecore/src/lib/ecore_win32/ecore_win32_event.c +++ /dev/null | |||
@@ -1,1295 +0,0 @@ | |||
1 | #ifdef HAVE_CONFIG_H | ||
2 | # include <config.h> | ||
3 | #endif | ||
4 | |||
5 | #include <stdlib.h> | ||
6 | #include <stdio.h> /* for printf */ | ||
7 | |||
8 | #define WIN32_LEAN_AND_MEAN | ||
9 | #include <windows.h> | ||
10 | #undef WIN32_LEAN_AND_MEAN | ||
11 | #include <windowsx.h> | ||
12 | |||
13 | #include <Eina.h> | ||
14 | #include <Ecore.h> | ||
15 | #include <Ecore_Input.h> | ||
16 | |||
17 | #include "Ecore_Win32.h" | ||
18 | #include "ecore_win32_private.h" | ||
19 | |||
20 | |||
21 | typedef enum | ||
22 | { | ||
23 | ECORE_WIN32_KEY_MASK_LSHIFT = 1 << 0, | ||
24 | ECORE_WIN32_KEY_MASK_RSHIFT = 1 << 1, | ||
25 | ECORE_WIN32_KEY_MASK_LCONTROL = 1 << 2, | ||
26 | ECORE_WIN32_KEY_MASK_RCONTROL = 1 << 3, | ||
27 | ECORE_WIN32_KEY_MASK_LMENU = 1 << 4, | ||
28 | ECORE_WIN32_KEY_MASK_RMENU = 1 << 5 | ||
29 | } Ecore_Win32_Key_Mask; | ||
30 | |||
31 | /***** Private declarations *****/ | ||
32 | |||
33 | |||
34 | static Ecore_Win32_Window *_ecore_win32_mouse_down_last_window = NULL; | ||
35 | static Ecore_Win32_Window *_ecore_win32_mouse_down_last_last_window = NULL; | ||
36 | static long _ecore_win32_mouse_down_last_time = 0 ; | ||
37 | static long _ecore_win32_mouse_down_last_last_time = 0 ; | ||
38 | static int _ecore_win32_mouse_down_did_triple = 0; | ||
39 | static int _ecore_win32_mouse_up_count = 0; | ||
40 | static Ecore_Win32_Key_Mask _ecore_win32_key_mask = 0; | ||
41 | |||
42 | static void _ecore_win32_event_free_key_down(void *data, | ||
43 | void *ev); | ||
44 | |||
45 | static void _ecore_win32_event_free_key_up(void *data, | ||
46 | void *ev); | ||
47 | |||
48 | static int _ecore_win32_event_keystroke_get(Ecore_Win32_Callback_Data *msg, | ||
49 | Eina_Bool is_down, | ||
50 | char **keyname, | ||
51 | char **keysymbol, | ||
52 | char **keycompose, | ||
53 | unsigned int *modifiers); | ||
54 | |||
55 | static int _ecore_win32_event_char_get(int key, | ||
56 | char **keyname, | ||
57 | char **keysymbol, | ||
58 | char **keycompose, | ||
59 | unsigned int *modifiers); | ||
60 | |||
61 | |||
62 | /***** Global functions definitions *****/ | ||
63 | |||
64 | void | ||
65 | _ecore_win32_event_handle_key_press(Ecore_Win32_Callback_Data *msg, | ||
66 | int is_keystroke) | ||
67 | { | ||
68 | Ecore_Event_Key *e; | ||
69 | |||
70 | INF("key pressed"); | ||
71 | |||
72 | e = (Ecore_Event_Key *)calloc(1, sizeof(Ecore_Event_Key)); | ||
73 | if (!e) return; | ||
74 | |||
75 | if (is_keystroke) | ||
76 | { | ||
77 | if (!_ecore_win32_event_keystroke_get(msg, | ||
78 | EINA_TRUE, | ||
79 | (char **)&e->keyname, | ||
80 | (char **)&e->key, | ||
81 | (char **)&e->string, | ||
82 | &e->modifiers)) | ||
83 | { | ||
84 | free(e); | ||
85 | return; | ||
86 | } | ||
87 | } | ||
88 | else | ||
89 | { | ||
90 | if (!_ecore_win32_event_char_get(LOWORD(msg->window_param), | ||
91 | (char **)&e->keyname, | ||
92 | (char **)&e->key, | ||
93 | (char **)&e->string, | ||
94 | &e->modifiers)) | ||
95 | { | ||
96 | free(e); | ||
97 | return; | ||
98 | } | ||
99 | } | ||
100 | |||
101 | e->window = (Ecore_Window)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
102 | if (!e->window) | ||
103 | { | ||
104 | free(e); | ||
105 | return; | ||
106 | } | ||
107 | e->event_window = e->window; | ||
108 | e->timestamp = msg->timestamp; | ||
109 | |||
110 | _ecore_win32_event_last_time = e->timestamp; | ||
111 | |||
112 | ecore_event_add(ECORE_EVENT_KEY_DOWN, e, _ecore_win32_event_free_key_down, NULL); | ||
113 | } | ||
114 | |||
115 | void | ||
116 | _ecore_win32_event_handle_key_release(Ecore_Win32_Callback_Data *msg) | ||
117 | { | ||
118 | Ecore_Event_Key *e; | ||
119 | |||
120 | INF("key released"); | ||
121 | |||
122 | e = (Ecore_Event_Key *)calloc(1, sizeof(Ecore_Event_Key)); | ||
123 | if (!e) return; | ||
124 | |||
125 | if (!_ecore_win32_event_keystroke_get(msg, | ||
126 | EINA_FALSE, | ||
127 | (char **)&e->keyname, | ||
128 | (char **)&e->key, | ||
129 | (char **)&e->string, | ||
130 | &e->modifiers)) | ||
131 | { | ||
132 | if (msg->discard_ctrl || | ||
133 | !_ecore_win32_event_char_get(LOWORD(msg->window_param), | ||
134 | (char **)&e->keyname, | ||
135 | (char **)&e->key, | ||
136 | (char **)&e->string, | ||
137 | &e->modifiers)) | ||
138 | { | ||
139 | free(e); | ||
140 | return; | ||
141 | } | ||
142 | } | ||
143 | |||
144 | e->window = (Ecore_Window)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
145 | if (!e->window) | ||
146 | { | ||
147 | free(e); | ||
148 | return; | ||
149 | } | ||
150 | e->event_window = e->window; | ||
151 | e->timestamp = msg->timestamp; | ||
152 | |||
153 | _ecore_win32_event_last_time = e->timestamp; | ||
154 | |||
155 | ecore_event_add(ECORE_EVENT_KEY_UP, e, _ecore_win32_event_free_key_up, NULL); | ||
156 | } | ||
157 | |||
158 | void | ||
159 | _ecore_win32_event_handle_button_press(Ecore_Win32_Callback_Data *msg, | ||
160 | int button) | ||
161 | { | ||
162 | Ecore_Win32_Window *window; | ||
163 | |||
164 | INF("mouse button pressed"); | ||
165 | |||
166 | window = (Ecore_Win32_Window *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
167 | |||
168 | if (button > 3) | ||
169 | { | ||
170 | Ecore_Event_Mouse_Wheel *e; | ||
171 | |||
172 | e = (Ecore_Event_Mouse_Wheel *)calloc(1, sizeof(Ecore_Event_Mouse_Wheel)); | ||
173 | if (!e) return; | ||
174 | |||
175 | e->window = (Ecore_Window)window; | ||
176 | e->event_window = e->window; | ||
177 | e->direction = 0; | ||
178 | /* wheel delta is positive or negative, never 0 */ | ||
179 | e->z = GET_WHEEL_DELTA_WPARAM(msg->window_param) > 0 ? -1 : 1; | ||
180 | e->x = GET_X_LPARAM(msg->data_param); | ||
181 | e->y = GET_Y_LPARAM(msg->data_param); | ||
182 | e->timestamp = msg->timestamp; | ||
183 | |||
184 | _ecore_win32_event_last_time = e->timestamp; | ||
185 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
186 | |||
187 | ecore_event_add(ECORE_EVENT_MOUSE_WHEEL, e, NULL, NULL); | ||
188 | } | ||
189 | else | ||
190 | { | ||
191 | { | ||
192 | Ecore_Event_Mouse_Move *e; | ||
193 | |||
194 | e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move)); | ||
195 | if (!e) return; | ||
196 | |||
197 | e->window = (Ecore_Window)window; | ||
198 | e->event_window = e->window; | ||
199 | e->x = GET_X_LPARAM(msg->data_param); | ||
200 | e->y = GET_Y_LPARAM(msg->data_param); | ||
201 | e->timestamp = msg->timestamp; | ||
202 | |||
203 | _ecore_win32_event_last_time = e->timestamp; | ||
204 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
205 | |||
206 | ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL); | ||
207 | } | ||
208 | |||
209 | { | ||
210 | Ecore_Event_Mouse_Button *e; | ||
211 | |||
212 | if (_ecore_win32_mouse_down_did_triple) | ||
213 | { | ||
214 | _ecore_win32_mouse_down_last_window = NULL; | ||
215 | _ecore_win32_mouse_down_last_last_window = NULL; | ||
216 | _ecore_win32_mouse_down_last_time = 0; | ||
217 | _ecore_win32_mouse_down_last_last_time = 0; | ||
218 | } | ||
219 | |||
220 | e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button)); | ||
221 | if (!e) return; | ||
222 | |||
223 | e->window = (Ecore_Window)window; | ||
224 | e->event_window = e->window; | ||
225 | e->buttons = button; | ||
226 | e->x = GET_X_LPARAM(msg->data_param); | ||
227 | e->y = GET_Y_LPARAM(msg->data_param); | ||
228 | e->timestamp = msg->timestamp; | ||
229 | |||
230 | if (((e->timestamp - _ecore_win32_mouse_down_last_time) <= (unsigned long)(1000 * _ecore_win32_double_click_time)) && | ||
231 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_window)) | ||
232 | e->double_click = 1; | ||
233 | |||
234 | if (((e->timestamp - _ecore_win32_mouse_down_last_last_time) <= (unsigned long)(2 * 1000 * _ecore_win32_double_click_time)) && | ||
235 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_window) && | ||
236 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_last_window)) | ||
237 | { | ||
238 | e->triple_click = 1; | ||
239 | _ecore_win32_mouse_down_did_triple = 1; | ||
240 | } | ||
241 | else | ||
242 | _ecore_win32_mouse_down_did_triple = 0; | ||
243 | |||
244 | if (!e->double_click && !e->triple_click) | ||
245 | _ecore_win32_mouse_up_count = 0; | ||
246 | |||
247 | _ecore_win32_event_last_time = e->timestamp; | ||
248 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
249 | |||
250 | if (!_ecore_win32_mouse_down_did_triple) | ||
251 | { | ||
252 | _ecore_win32_mouse_down_last_last_window = _ecore_win32_mouse_down_last_window; | ||
253 | _ecore_win32_mouse_down_last_window = (Ecore_Win32_Window *)e->window; | ||
254 | _ecore_win32_mouse_down_last_last_time = _ecore_win32_mouse_down_last_time; | ||
255 | _ecore_win32_mouse_down_last_time = e->timestamp; | ||
256 | } | ||
257 | |||
258 | ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, e, NULL, NULL); | ||
259 | } | ||
260 | } | ||
261 | } | ||
262 | |||
263 | void | ||
264 | _ecore_win32_event_handle_button_release(Ecore_Win32_Callback_Data *msg, | ||
265 | int button) | ||
266 | { | ||
267 | Ecore_Win32_Window *window; | ||
268 | |||
269 | INF("mouse button released"); | ||
270 | |||
271 | window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
272 | |||
273 | { | ||
274 | Ecore_Event_Mouse_Move *e; | ||
275 | |||
276 | e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move)); | ||
277 | if (!e) return; | ||
278 | |||
279 | e->window = (Ecore_Window)window; | ||
280 | e->event_window = e->window; | ||
281 | e->x = GET_X_LPARAM(msg->data_param); | ||
282 | e->y = GET_Y_LPARAM(msg->data_param); | ||
283 | e->timestamp = msg->timestamp; | ||
284 | |||
285 | _ecore_win32_event_last_time = e->timestamp; | ||
286 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
287 | |||
288 | ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL); | ||
289 | } | ||
290 | |||
291 | { | ||
292 | Ecore_Event_Mouse_Button *e; | ||
293 | |||
294 | e = (Ecore_Event_Mouse_Button *)calloc(1, sizeof(Ecore_Event_Mouse_Button)); | ||
295 | if (!e) return; | ||
296 | |||
297 | e->window = (Ecore_Window)window; | ||
298 | e->event_window = e->window; | ||
299 | e->buttons = button; | ||
300 | e->x = GET_X_LPARAM(msg->data_param); | ||
301 | e->y = GET_Y_LPARAM(msg->data_param); | ||
302 | e->timestamp = msg->timestamp; | ||
303 | |||
304 | _ecore_win32_mouse_up_count++; | ||
305 | |||
306 | if ((_ecore_win32_mouse_up_count >= 2) && | ||
307 | ((e->timestamp - _ecore_win32_mouse_down_last_time) <= (unsigned long)(1000 * _ecore_win32_double_click_time)) && | ||
308 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_window)) | ||
309 | e->double_click = 1; | ||
310 | |||
311 | if ((_ecore_win32_mouse_up_count >= 3) && | ||
312 | ((e->timestamp - _ecore_win32_mouse_down_last_last_time) <= (unsigned long)(2 * 1000 * _ecore_win32_double_click_time)) && | ||
313 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_window) && | ||
314 | (e->window == (Ecore_Window)_ecore_win32_mouse_down_last_last_window)) | ||
315 | e->triple_click = 1; | ||
316 | |||
317 | _ecore_win32_event_last_time = e->timestamp; | ||
318 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
319 | |||
320 | ecore_event_add(ECORE_EVENT_MOUSE_BUTTON_UP, e, NULL, NULL); | ||
321 | } | ||
322 | } | ||
323 | |||
324 | void | ||
325 | _ecore_win32_event_handle_motion_notify(Ecore_Win32_Callback_Data *msg) | ||
326 | { | ||
327 | Ecore_Event_Mouse_Move *e; | ||
328 | |||
329 | INF("mouse moved"); | ||
330 | |||
331 | e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move)); | ||
332 | if (!e) return; | ||
333 | |||
334 | e->window = (Ecore_Window)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
335 | e->event_window = e->window; | ||
336 | e->x = GET_X_LPARAM(msg->data_param); | ||
337 | e->y = GET_Y_LPARAM(msg->data_param); | ||
338 | e->timestamp = msg->timestamp; | ||
339 | |||
340 | ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL); | ||
341 | } | ||
342 | |||
343 | void | ||
344 | _ecore_win32_event_handle_enter_notify(Ecore_Win32_Callback_Data *msg) | ||
345 | { | ||
346 | { | ||
347 | Ecore_Event_Mouse_Move *e; | ||
348 | |||
349 | INF("mouse in"); | ||
350 | |||
351 | e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move)); | ||
352 | if (!e) return; | ||
353 | |||
354 | e->window = (Ecore_Window)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
355 | e->event_window = e->window; | ||
356 | e->x = msg->x; | ||
357 | e->y = msg->y; | ||
358 | e->timestamp = msg->timestamp; | ||
359 | |||
360 | _ecore_win32_event_last_time = e->timestamp; | ||
361 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
362 | |||
363 | ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL); | ||
364 | } | ||
365 | |||
366 | { | ||
367 | Ecore_Win32_Event_Mouse_In *e; | ||
368 | |||
369 | e = (Ecore_Win32_Event_Mouse_In *)calloc(1, sizeof(Ecore_Win32_Event_Mouse_In)); | ||
370 | if (!e) return; | ||
371 | |||
372 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
373 | e->x = msg->x; | ||
374 | e->y = msg->y; | ||
375 | e->timestamp = msg->timestamp ; | ||
376 | |||
377 | _ecore_win32_event_last_time = e->timestamp; | ||
378 | |||
379 | ecore_event_add(ECORE_WIN32_EVENT_MOUSE_IN, e, NULL, NULL); | ||
380 | } | ||
381 | } | ||
382 | |||
383 | void | ||
384 | _ecore_win32_event_handle_leave_notify(Ecore_Win32_Callback_Data *msg) | ||
385 | { | ||
386 | { | ||
387 | Ecore_Event_Mouse_Move *e; | ||
388 | |||
389 | INF("mouse out"); | ||
390 | |||
391 | e = (Ecore_Event_Mouse_Move *)calloc(1, sizeof(Ecore_Event_Mouse_Move)); | ||
392 | if (!e) return; | ||
393 | |||
394 | e->window = (Ecore_Window)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
395 | e->event_window = e->window; | ||
396 | e->x = msg->x; | ||
397 | e->y = msg->y; | ||
398 | e->timestamp = msg->timestamp; | ||
399 | |||
400 | _ecore_win32_event_last_time = e->timestamp; | ||
401 | _ecore_win32_event_last_window = (Ecore_Win32_Window *)e->window; | ||
402 | |||
403 | ecore_event_add(ECORE_EVENT_MOUSE_MOVE, e, NULL, NULL); | ||
404 | } | ||
405 | |||
406 | { | ||
407 | Ecore_Win32_Event_Mouse_Out *e; | ||
408 | |||
409 | e = (Ecore_Win32_Event_Mouse_Out *)calloc(1, sizeof(Ecore_Win32_Event_Mouse_Out)); | ||
410 | if (!e) return; | ||
411 | |||
412 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
413 | e->x = msg->x; | ||
414 | e->y = msg->y; | ||
415 | e->timestamp = msg->timestamp; | ||
416 | |||
417 | _ecore_win32_event_last_time = e->timestamp; | ||
418 | |||
419 | ecore_event_add(ECORE_WIN32_EVENT_MOUSE_OUT, e, NULL, NULL); | ||
420 | } | ||
421 | } | ||
422 | |||
423 | void | ||
424 | _ecore_win32_event_handle_focus_in(Ecore_Win32_Callback_Data *msg) | ||
425 | { | ||
426 | Ecore_Win32_Event_Window_Focus_In *e; | ||
427 | |||
428 | INF("focus in"); | ||
429 | |||
430 | e = (Ecore_Win32_Event_Window_Focus_In *)calloc(1, sizeof(Ecore_Win32_Event_Window_Focus_In)); | ||
431 | if (!e) return; | ||
432 | |||
433 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
434 | |||
435 | e->timestamp = _ecore_win32_event_last_time; | ||
436 | _ecore_win32_event_last_time = e->timestamp; | ||
437 | |||
438 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_FOCUS_IN, e, NULL, NULL); | ||
439 | } | ||
440 | |||
441 | void | ||
442 | _ecore_win32_event_handle_focus_out(Ecore_Win32_Callback_Data *msg) | ||
443 | { | ||
444 | Ecore_Win32_Event_Window_Focus_Out *e; | ||
445 | |||
446 | INF("focus out"); | ||
447 | |||
448 | e = (Ecore_Win32_Event_Window_Focus_Out *)calloc(1, sizeof(Ecore_Win32_Event_Window_Focus_Out)); | ||
449 | if (!e) return; | ||
450 | |||
451 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
452 | |||
453 | e->timestamp = _ecore_win32_event_last_time; | ||
454 | _ecore_win32_event_last_time = e->timestamp; | ||
455 | |||
456 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_FOCUS_OUT, e, NULL, NULL); | ||
457 | } | ||
458 | |||
459 | void | ||
460 | _ecore_win32_event_handle_expose(Ecore_Win32_Callback_Data *msg) | ||
461 | { | ||
462 | Ecore_Win32_Event_Window_Damage *e; | ||
463 | |||
464 | INF("window expose"); | ||
465 | |||
466 | e = (Ecore_Win32_Event_Window_Damage *)calloc(1, sizeof(Ecore_Win32_Event_Window_Damage)); | ||
467 | if (!e) return; | ||
468 | |||
469 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
470 | |||
471 | e->x = msg->update.left; | ||
472 | e->y = msg->update.top; | ||
473 | e->width = msg->update.right - msg->update.left; | ||
474 | e->height = msg->update.bottom - msg->update.top; | ||
475 | |||
476 | e->timestamp = _ecore_win32_event_last_time; | ||
477 | |||
478 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_DAMAGE, e, NULL, NULL); | ||
479 | } | ||
480 | |||
481 | void | ||
482 | _ecore_win32_event_handle_create_notify(Ecore_Win32_Callback_Data *msg) | ||
483 | { | ||
484 | Ecore_Win32_Event_Window_Create *e; | ||
485 | |||
486 | INF("window create notify"); | ||
487 | |||
488 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Create)); | ||
489 | if (!e) return; | ||
490 | |||
491 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
492 | |||
493 | e->timestamp = _ecore_win32_event_last_time; | ||
494 | |||
495 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_CREATE, e, NULL, NULL); | ||
496 | } | ||
497 | |||
498 | void | ||
499 | _ecore_win32_event_handle_destroy_notify(Ecore_Win32_Callback_Data *msg) | ||
500 | { | ||
501 | Ecore_Win32_Event_Window_Destroy *e; | ||
502 | |||
503 | INF("window destroy notify"); | ||
504 | |||
505 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Destroy)); | ||
506 | if (!e) return; | ||
507 | |||
508 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
509 | |||
510 | e->timestamp = _ecore_win32_event_last_time; | ||
511 | if (e->window == _ecore_win32_event_last_window) _ecore_win32_event_last_window = NULL; | ||
512 | |||
513 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_DESTROY, e, NULL, NULL); | ||
514 | } | ||
515 | |||
516 | void | ||
517 | _ecore_win32_event_handle_map_notify(Ecore_Win32_Callback_Data *msg) | ||
518 | { | ||
519 | Ecore_Win32_Event_Window_Show *e; | ||
520 | |||
521 | INF("window map notify"); | ||
522 | |||
523 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Show)); | ||
524 | if (!e) return; | ||
525 | |||
526 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
527 | |||
528 | e->timestamp = _ecore_win32_event_last_time; | ||
529 | |||
530 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_SHOW, e, NULL, NULL); | ||
531 | } | ||
532 | |||
533 | void | ||
534 | _ecore_win32_event_handle_unmap_notify(Ecore_Win32_Callback_Data *msg) | ||
535 | { | ||
536 | Ecore_Win32_Event_Window_Hide *e; | ||
537 | |||
538 | INF("window unmap notify"); | ||
539 | |||
540 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Hide)); | ||
541 | if (!e) return; | ||
542 | |||
543 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
544 | |||
545 | e->timestamp = _ecore_win32_event_last_time; | ||
546 | |||
547 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_HIDE, e, NULL, NULL); | ||
548 | } | ||
549 | |||
550 | void | ||
551 | _ecore_win32_event_handle_configure_notify(Ecore_Win32_Callback_Data *msg) | ||
552 | { | ||
553 | WINDOWINFO wi; | ||
554 | Ecore_Win32_Event_Window_Configure *e; | ||
555 | WINDOWPOS *window_pos; | ||
556 | |||
557 | INF("window configure notify"); | ||
558 | |||
559 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Configure)); | ||
560 | if (!e) return; | ||
561 | |||
562 | window_pos = (WINDOWPOS *)msg->data_param; | ||
563 | wi.cbSize = sizeof(WINDOWINFO); | ||
564 | if (!GetWindowInfo(window_pos->hwnd, &wi)) | ||
565 | { | ||
566 | free(e); | ||
567 | return; | ||
568 | } | ||
569 | |||
570 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
571 | e->abovewin = (void *)GetWindowLongPtr(window_pos->hwndInsertAfter, GWLP_USERDATA); | ||
572 | e->x = wi.rcClient.left; | ||
573 | e->y = wi.rcClient.top; | ||
574 | e->width = wi.rcClient.right - wi.rcClient.left; | ||
575 | e->height = wi.rcClient.bottom - wi.rcClient.top; | ||
576 | e->timestamp = _ecore_win32_event_last_time; | ||
577 | |||
578 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_CONFIGURE, e, NULL, NULL); | ||
579 | } | ||
580 | |||
581 | void | ||
582 | _ecore_win32_event_handle_resize(Ecore_Win32_Callback_Data *msg) | ||
583 | { | ||
584 | RECT rect; | ||
585 | Ecore_Win32_Event_Window_Resize *e; | ||
586 | |||
587 | INF("window resize"); | ||
588 | |||
589 | if (!GetClientRect(msg->window, &rect)) | ||
590 | return; | ||
591 | |||
592 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Resize)); | ||
593 | if (!e) return; | ||
594 | |||
595 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
596 | e->width = rect.right - rect.left; | ||
597 | e->height = rect.bottom - rect.top; | ||
598 | e->timestamp = _ecore_win32_event_last_time; | ||
599 | |||
600 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_RESIZE, e, NULL, NULL); | ||
601 | } | ||
602 | |||
603 | void | ||
604 | _ecore_win32_event_handle_delete_request(Ecore_Win32_Callback_Data *msg) | ||
605 | { | ||
606 | Ecore_Win32_Event_Window_Delete_Request *e; | ||
607 | |||
608 | INF("window delete request"); | ||
609 | |||
610 | e = calloc(1, sizeof(Ecore_Win32_Event_Window_Delete_Request)); | ||
611 | if (!e) return; | ||
612 | |||
613 | e->window = (void *)GetWindowLongPtr(msg->window, GWLP_USERDATA); | ||
614 | e->timestamp = _ecore_win32_event_last_time; | ||
615 | |||
616 | ecore_event_add(ECORE_WIN32_EVENT_WINDOW_DELETE_REQUEST, e, NULL, NULL); | ||
617 | } | ||
618 | |||
619 | |||
620 | /***** Private functions definitions *****/ | ||
621 | |||
622 | static void | ||
623 | _ecore_win32_event_free_key_down(void *data __UNUSED__, | ||
624 | void *ev) | ||
625 | { | ||
626 | Ecore_Event_Key *e; | ||
627 | |||
628 | e = ev; | ||
629 | if (e->keyname) free((char *)e->keyname); | ||
630 | if (e->key) free((char *)e->key); | ||
631 | if (e->string) free((char *)e->string); | ||
632 | free(e); | ||
633 | } | ||
634 | |||
635 | static void | ||
636 | _ecore_win32_event_free_key_up(void *data __UNUSED__, | ||
637 | void *ev) | ||
638 | { | ||
639 | Ecore_Event_Key *e; | ||
640 | |||
641 | e = ev; | ||
642 | if (e->keyname) free((char *)e->keyname); | ||
643 | if (e->key) free((char *)e->key); | ||
644 | if (e->string) free((char *)e->string); | ||
645 | free(e); | ||
646 | } | ||
647 | |||
648 | static int | ||
649 | _ecore_win32_event_keystroke_get(Ecore_Win32_Callback_Data *msg, | ||
650 | Eina_Bool is_down, | ||
651 | char **keyname, | ||
652 | char **keysymbol, | ||
653 | char **keycompose, | ||
654 | unsigned int *modifiers) | ||
655 | { | ||
656 | WCHAR buf[3]; | ||
657 | char delete_string[2] = { 0x7f, 0 }; | ||
658 | char *kn = NULL; | ||
659 | char *ks = NULL; | ||
660 | char *kc = NULL; | ||
661 | int key; | ||
662 | int is_extended; | ||
663 | |||
664 | key = msg->window_param; | ||
665 | is_extended = msg->data_param & 0x01000000; | ||
666 | |||
667 | *keyname = NULL; | ||
668 | *keysymbol = NULL; | ||
669 | *keycompose = NULL; | ||
670 | |||
671 | switch (key) | ||
672 | { | ||
673 | /* Keystroke */ | ||
674 | case VK_PRIOR: | ||
675 | if (is_extended) | ||
676 | { | ||
677 | kn = "Prior"; | ||
678 | ks = "Prior"; | ||
679 | kc = NULL; | ||
680 | } | ||
681 | else | ||
682 | { | ||
683 | kn = "KP_Prior"; | ||
684 | ks = "KP_9"; | ||
685 | kc = "KP_Prior"; | ||
686 | } | ||
687 | break; | ||
688 | case VK_NEXT: | ||
689 | if (is_extended) | ||
690 | { | ||
691 | kn = "Next"; | ||
692 | ks = "Next"; | ||
693 | kc = NULL; | ||
694 | } | ||
695 | else | ||
696 | { | ||
697 | kn = "KP_Next"; | ||
698 | ks = "KP_3"; | ||
699 | kc = "KP_Next"; | ||
700 | } | ||
701 | break; | ||
702 | case VK_END: | ||
703 | if (is_extended) | ||
704 | { | ||
705 | kn = "End"; | ||
706 | ks = "End"; | ||
707 | kc = NULL; | ||
708 | } | ||
709 | else | ||
710 | { | ||
711 | kn = "KP_End"; | ||
712 | ks = "KP_1"; | ||
713 | kc = "KP_End"; | ||
714 | } | ||
715 | break; | ||
716 | case VK_HOME: | ||
717 | if (is_extended) | ||
718 | { | ||
719 | kn = "Home"; | ||
720 | ks = "Home"; | ||
721 | kc = NULL; | ||
722 | } | ||
723 | else | ||
724 | { | ||
725 | kn = "KP_Home"; | ||
726 | ks = "KP_7"; | ||
727 | kc = "KP_Home"; | ||
728 | } | ||
729 | break; | ||
730 | case VK_LEFT: | ||
731 | if (is_extended) | ||
732 | { | ||
733 | kn = "Left"; | ||
734 | ks = "Left"; | ||
735 | kc = NULL; | ||
736 | } | ||
737 | else | ||
738 | { | ||
739 | kn = "KP_Left"; | ||
740 | ks = "KP_4"; | ||
741 | kc = "KP_Left"; | ||
742 | } | ||
743 | break; | ||
744 | case VK_UP: | ||
745 | if (is_extended) | ||
746 | { | ||
747 | kn = "Up"; | ||
748 | ks = "Up"; | ||
749 | kc = NULL; | ||
750 | } | ||
751 | else | ||
752 | { | ||
753 | kn = "KP_Up"; | ||
754 | ks = "KP_8"; | ||
755 | kc = "KP_Up"; | ||
756 | } | ||
757 | break; | ||
758 | case VK_RIGHT: | ||
759 | if (is_extended) | ||
760 | { | ||
761 | kn = "Right"; | ||
762 | ks = "Right"; | ||
763 | kc = NULL; | ||
764 | } | ||
765 | else | ||
766 | { | ||
767 | kn = "KP_Right"; | ||
768 | ks = "KP_6"; | ||
769 | kc = "KP_Right"; | ||
770 | } | ||
771 | break; | ||
772 | case VK_DOWN: | ||
773 | if (is_extended) | ||
774 | { | ||
775 | kn = "Down"; | ||
776 | ks = "Down"; | ||
777 | kc = NULL; | ||
778 | } | ||
779 | else | ||
780 | { | ||
781 | kn = "KP_Down"; | ||
782 | ks = "KP_2"; | ||
783 | kc = "KP_Down"; | ||
784 | } | ||
785 | break; | ||
786 | case VK_INSERT: | ||
787 | if (is_extended) | ||
788 | { | ||
789 | kn = "Insert"; | ||
790 | ks = "Insert"; | ||
791 | kc = NULL; | ||
792 | } | ||
793 | else | ||
794 | { | ||
795 | kn = "KP_Insert"; | ||
796 | ks = "KP_0"; | ||
797 | kc = "KP_Insert"; | ||
798 | } | ||
799 | break; | ||
800 | case VK_DELETE: | ||
801 | if (is_extended) | ||
802 | { | ||
803 | kn = "Delete"; | ||
804 | ks = "Delete"; | ||
805 | kc = delete_string; | ||
806 | } | ||
807 | else | ||
808 | { | ||
809 | kn = "KP_Delete"; | ||
810 | ks = "KP_Decimal"; | ||
811 | kc = "KP_Delete"; | ||
812 | } | ||
813 | break; | ||
814 | case VK_SHIFT: | ||
815 | { | ||
816 | SHORT res; | ||
817 | |||
818 | if (is_down) | ||
819 | { | ||
820 | res = GetKeyState(VK_LSHIFT); | ||
821 | if (res & 0x8000) | ||
822 | { | ||
823 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_LSHIFT; | ||
824 | kn = "Shift_L"; | ||
825 | ks = "Shift_L"; | ||
826 | kc = ""; | ||
827 | } | ||
828 | res = GetKeyState(VK_RSHIFT); | ||
829 | if (res & 0x8000) | ||
830 | { | ||
831 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_RSHIFT; | ||
832 | kn = "Shift_R"; | ||
833 | ks = "Shift_R"; | ||
834 | kc = ""; | ||
835 | } | ||
836 | *modifiers &= ~ECORE_EVENT_MODIFIER_SHIFT; | ||
837 | } | ||
838 | else /* is_up */ | ||
839 | { | ||
840 | res = GetKeyState(VK_LSHIFT); | ||
841 | if (!(res & 0x8000) && | ||
842 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_LSHIFT)) | ||
843 | { | ||
844 | kn = "Shift_L"; | ||
845 | ks = "Shift_L"; | ||
846 | kc = ""; | ||
847 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_LSHIFT; | ||
848 | } | ||
849 | res = GetKeyState(VK_RSHIFT); | ||
850 | if (!(res & 0x8000) && | ||
851 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_RSHIFT)) | ||
852 | { | ||
853 | kn = "Shift_R"; | ||
854 | ks = "Shift_R"; | ||
855 | kc = ""; | ||
856 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_RSHIFT; | ||
857 | } | ||
858 | *modifiers |= ECORE_EVENT_MODIFIER_SHIFT; | ||
859 | } | ||
860 | break; | ||
861 | } | ||
862 | case VK_CONTROL: | ||
863 | { | ||
864 | SHORT res; | ||
865 | |||
866 | if (msg->discard_ctrl) | ||
867 | return 0; | ||
868 | |||
869 | if (is_down) | ||
870 | { | ||
871 | res = GetKeyState(VK_LCONTROL); | ||
872 | if (res & 0x8000) | ||
873 | { | ||
874 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_LCONTROL; | ||
875 | kn = "Control_L"; | ||
876 | ks = "Control_L"; | ||
877 | kc = ""; | ||
878 | break; | ||
879 | } | ||
880 | res = GetKeyState(VK_RCONTROL); | ||
881 | if (res & 0x8000) | ||
882 | { | ||
883 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_RCONTROL; | ||
884 | kn = "Control_R"; | ||
885 | ks = "Control_R"; | ||
886 | kc = ""; | ||
887 | break; | ||
888 | } | ||
889 | *modifiers |= ECORE_EVENT_MODIFIER_CTRL; | ||
890 | } | ||
891 | else /* is_up */ | ||
892 | { | ||
893 | res = GetKeyState(VK_LCONTROL); | ||
894 | if (!(res & 0x8000) && | ||
895 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_LCONTROL)) | ||
896 | { | ||
897 | kn = "Control_L"; | ||
898 | ks = "Control_L"; | ||
899 | kc = ""; | ||
900 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_LCONTROL; | ||
901 | break; | ||
902 | } | ||
903 | res = GetKeyState(VK_RCONTROL); | ||
904 | if (!(res & 0x8000) && | ||
905 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_RCONTROL)) | ||
906 | { | ||
907 | kn = "Control_R"; | ||
908 | ks = "Control_R"; | ||
909 | kc = ""; | ||
910 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_RCONTROL; | ||
911 | break; | ||
912 | } | ||
913 | *modifiers &= ~ECORE_EVENT_MODIFIER_CTRL; | ||
914 | } | ||
915 | break; | ||
916 | } | ||
917 | case VK_MENU: | ||
918 | { | ||
919 | SHORT res; | ||
920 | |||
921 | if (is_down) | ||
922 | { | ||
923 | res = GetKeyState(VK_LMENU); | ||
924 | if (res & 0x8000) | ||
925 | { | ||
926 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_LMENU; | ||
927 | kn = "Alt_L"; | ||
928 | ks = "Alt_L"; | ||
929 | kc = ""; | ||
930 | } | ||
931 | res = GetKeyState(VK_RMENU); | ||
932 | if (res & 0x8000) | ||
933 | { | ||
934 | _ecore_win32_key_mask |= ECORE_WIN32_KEY_MASK_RMENU; | ||
935 | kn = "Alt_R"; | ||
936 | ks = "Alt_R"; | ||
937 | kc = ""; | ||
938 | } | ||
939 | *modifiers |= ECORE_EVENT_MODIFIER_ALT; | ||
940 | } | ||
941 | else /* is_up */ | ||
942 | { | ||
943 | res = GetKeyState(VK_LMENU); | ||
944 | if (!(res & 0x8000) && | ||
945 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_LMENU)) | ||
946 | { | ||
947 | kn = "Alt_L"; | ||
948 | ks = "Alt_L"; | ||
949 | kc = ""; | ||
950 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_LMENU; | ||
951 | } | ||
952 | res = GetKeyState(VK_RMENU); | ||
953 | if (!(res & 0x8000) && | ||
954 | (_ecore_win32_key_mask & ECORE_WIN32_KEY_MASK_RMENU)) | ||
955 | { | ||
956 | kn = "Alt_R"; | ||
957 | ks = "Alt_R"; | ||
958 | kc = ""; | ||
959 | _ecore_win32_key_mask &= ~ECORE_WIN32_KEY_MASK_RMENU; | ||
960 | } | ||
961 | *modifiers &= ~ECORE_EVENT_MODIFIER_ALT; | ||
962 | } | ||
963 | break; | ||
964 | } | ||
965 | case VK_LWIN: | ||
966 | { | ||
967 | if (is_down) | ||
968 | { | ||
969 | kn = "Super_L"; | ||
970 | ks = "Super_L"; | ||
971 | kc = ""; | ||
972 | *modifiers |= ECORE_EVENT_MODIFIER_WIN; | ||
973 | } | ||
974 | else /* is_up */ | ||
975 | { | ||
976 | kn = "Super_L"; | ||
977 | ks = "Super_L"; | ||
978 | kc = ""; | ||
979 | *modifiers &= ~ECORE_EVENT_MODIFIER_WIN; | ||
980 | } | ||
981 | break; | ||
982 | } | ||
983 | case VK_RWIN: | ||
984 | { | ||
985 | if (is_down) | ||
986 | { | ||
987 | kn = "Super_R"; | ||
988 | ks = "Super_R"; | ||
989 | kc = ""; | ||
990 | *modifiers |= ECORE_EVENT_MODIFIER_WIN; | ||
991 | } | ||
992 | else /* is_up */ | ||
993 | { | ||
994 | kn = "Super_R"; | ||
995 | ks = "Super_R"; | ||
996 | kc = ""; | ||
997 | *modifiers &= ~ECORE_EVENT_MODIFIER_WIN; | ||
998 | } | ||
999 | break; | ||
1000 | } | ||
1001 | case VK_F1: | ||
1002 | kn = "F1"; | ||
1003 | ks = "F1"; | ||
1004 | kc = ""; | ||
1005 | break; | ||
1006 | case VK_F2: | ||
1007 | kn = "F2"; | ||
1008 | ks = "F2"; | ||
1009 | kc = ""; | ||
1010 | break; | ||
1011 | case VK_F3: | ||
1012 | kn = "F3"; | ||
1013 | ks = "F3"; | ||
1014 | kc = ""; | ||
1015 | break; | ||
1016 | case VK_F4: | ||
1017 | kn = "F4"; | ||
1018 | ks = "F4"; | ||
1019 | kc = ""; | ||
1020 | break; | ||
1021 | case VK_F5: | ||
1022 | kn = "F5"; | ||
1023 | ks = "F5"; | ||
1024 | kc = ""; | ||
1025 | break; | ||
1026 | case VK_F6: | ||
1027 | kn = "F6"; | ||
1028 | ks = "F6"; | ||
1029 | kc = ""; | ||
1030 | break; | ||
1031 | case VK_F7: | ||
1032 | kn = "F7"; | ||
1033 | ks = "F7"; | ||
1034 | kc = ""; | ||
1035 | break; | ||
1036 | case VK_F8: | ||
1037 | kn = "F8"; | ||
1038 | ks = "F8"; | ||
1039 | kc = ""; | ||
1040 | break; | ||
1041 | case VK_F9: | ||
1042 | kn = "F9"; | ||
1043 | ks = "F9"; | ||
1044 | kc = ""; | ||
1045 | break; | ||
1046 | case VK_F10: | ||
1047 | kn = "F10"; | ||
1048 | ks = "F10"; | ||
1049 | kc = ""; | ||
1050 | break; | ||
1051 | case VK_F11: | ||
1052 | kn = "F11"; | ||
1053 | ks = "F11"; | ||
1054 | kc = ""; | ||
1055 | break; | ||
1056 | case VK_F12: | ||
1057 | kn = "F12"; | ||
1058 | ks = "F12"; | ||
1059 | kc = ""; | ||
1060 | break; | ||
1061 | case VK_F13: | ||
1062 | kn = "F13"; | ||
1063 | ks = "F13"; | ||
1064 | kc = ""; | ||
1065 | break; | ||
1066 | case VK_F14: | ||
1067 | kn = "F14"; | ||
1068 | ks = "F14"; | ||
1069 | kc = ""; | ||
1070 | break; | ||
1071 | case VK_F15: | ||
1072 | kn = "F15"; | ||
1073 | ks = "F15"; | ||
1074 | kc = ""; | ||
1075 | break; | ||
1076 | case VK_F16: | ||
1077 | kn = "F16"; | ||
1078 | ks = "F16"; | ||
1079 | kc = ""; | ||
1080 | break; | ||
1081 | case VK_F17: | ||
1082 | kn = "F17"; | ||
1083 | ks = "F17"; | ||
1084 | kc = ""; | ||
1085 | break; | ||
1086 | case VK_F18: | ||
1087 | kn = "F18"; | ||
1088 | ks = "F18"; | ||
1089 | kc = ""; | ||
1090 | break; | ||
1091 | case VK_F19: | ||
1092 | kn = "F19"; | ||
1093 | ks = "F19"; | ||
1094 | kc = ""; | ||
1095 | break; | ||
1096 | case VK_F20: | ||
1097 | kn = "F20"; | ||
1098 | ks = "F20"; | ||
1099 | kc = ""; | ||
1100 | break; | ||
1101 | case VK_F21: | ||
1102 | kn = "F21"; | ||
1103 | ks = "F21"; | ||
1104 | kc = ""; | ||
1105 | break; | ||
1106 | case VK_F22: | ||
1107 | kn = "F22"; | ||
1108 | ks = "F22"; | ||
1109 | kc = ""; | ||
1110 | break; | ||
1111 | case VK_F23: | ||
1112 | kn = "F23"; | ||
1113 | ks = "F23"; | ||
1114 | kc = ""; | ||
1115 | break; | ||
1116 | case VK_F24: | ||
1117 | kn = "F24"; | ||
1118 | ks = "F24"; | ||
1119 | kc = ""; | ||
1120 | break; | ||
1121 | default: | ||
1122 | { | ||
1123 | /* other non keystroke characters */ | ||
1124 | BYTE kbd_state[256]; | ||
1125 | int res; | ||
1126 | |||
1127 | if (is_down) | ||
1128 | return 0; | ||
1129 | |||
1130 | if (!GetKeyboardState(kbd_state)) | ||
1131 | return 0; | ||
1132 | |||
1133 | res = ToUnicode(msg->window_param, | ||
1134 | MapVirtualKey(msg->window_param, 2), | ||
1135 | kbd_state, buf, 3, 0); | ||
1136 | if (res == 1) | ||
1137 | { | ||
1138 | /* FIXME: might be troublesome for non european languages */ | ||
1139 | /* in that case, UNICODE should be used, I guess */ | ||
1140 | buf[1] = '\0'; | ||
1141 | kn = (char *)buf; | ||
1142 | ks = (char *)buf; | ||
1143 | kc = (char *)buf; | ||
1144 | |||
1145 | res = GetAsyncKeyState(VK_SHIFT); | ||
1146 | if (res & 0x8000) | ||
1147 | *modifiers |= ECORE_EVENT_MODIFIER_SHIFT; | ||
1148 | else | ||
1149 | *modifiers &= ~ECORE_EVENT_MODIFIER_SHIFT; | ||
1150 | |||
1151 | res = GetKeyState(VK_CONTROL); | ||
1152 | if (res & 0x8000) | ||
1153 | *modifiers |= ECORE_EVENT_MODIFIER_CTRL; | ||
1154 | else | ||
1155 | *modifiers &= ~ECORE_EVENT_MODIFIER_CTRL; | ||
1156 | |||
1157 | res = GetKeyState(VK_MENU); | ||
1158 | if (res & 0x8000) | ||
1159 | *modifiers |= ECORE_EVENT_MODIFIER_ALT; | ||
1160 | else | ||
1161 | *modifiers &= ~ECORE_EVENT_MODIFIER_ALT; | ||
1162 | |||
1163 | break; | ||
1164 | } | ||
1165 | return 0; | ||
1166 | } | ||
1167 | } | ||
1168 | |||
1169 | *keyname = strdup(kn); | ||
1170 | if (!*keyname) return 0; | ||
1171 | *keysymbol = strdup(ks); | ||
1172 | if (!*keysymbol) | ||
1173 | { | ||
1174 | free(*keyname); | ||
1175 | *keyname = NULL; | ||
1176 | return 0; | ||
1177 | } | ||
1178 | if (!kc) | ||
1179 | *keycompose = NULL; | ||
1180 | else | ||
1181 | { | ||
1182 | *keycompose = strdup(kc); | ||
1183 | if (!*keycompose) | ||
1184 | { | ||
1185 | free(*keyname); | ||
1186 | free(*keysymbol); | ||
1187 | *keyname = NULL; | ||
1188 | *keysymbol = NULL; | ||
1189 | return 0; | ||
1190 | } | ||
1191 | } | ||
1192 | |||
1193 | return 1; | ||
1194 | } | ||
1195 | |||
1196 | static int | ||
1197 | _ecore_win32_event_char_get(int key, | ||
1198 | char **keyname, | ||
1199 | char **keysymbol, | ||
1200 | char **keycompose, | ||
1201 | unsigned int *modifiers) | ||
1202 | { | ||
1203 | char *kn = NULL; | ||
1204 | char *ks = NULL; | ||
1205 | char *kc = NULL; | ||
1206 | char buf[2]; | ||
1207 | SHORT res; | ||
1208 | |||
1209 | *keyname = NULL; | ||
1210 | *keysymbol = NULL; | ||
1211 | *keycompose = NULL; | ||
1212 | |||
1213 | switch (key) | ||
1214 | { | ||
1215 | case VK_PROCESSKEY: | ||
1216 | break; | ||
1217 | case VK_BACK: | ||
1218 | kn = "BackSpace"; | ||
1219 | ks = "BackSpace"; | ||
1220 | kc = "\b"; | ||
1221 | break; | ||
1222 | case VK_TAB: | ||
1223 | kn = "Tab"; | ||
1224 | ks = "Tab"; | ||
1225 | kc = "\t"; | ||
1226 | break; | ||
1227 | case 0x0a: | ||
1228 | /* Line feed (Shift + Enter) */ | ||
1229 | kn = "LineFeed"; | ||
1230 | ks = "LineFeed"; | ||
1231 | kc = "LineFeed"; | ||
1232 | break; | ||
1233 | case VK_RETURN: | ||
1234 | kn = "Return"; | ||
1235 | ks = "Return"; | ||
1236 | kc = "\n"; | ||
1237 | break; | ||
1238 | case VK_ESCAPE: | ||
1239 | kn = "Escape"; | ||
1240 | ks = "Escape"; | ||
1241 | kc = "\e"; | ||
1242 | break; | ||
1243 | case VK_SPACE: | ||
1244 | kn = "space"; | ||
1245 | ks = "space"; | ||
1246 | kc = " "; | ||
1247 | break; | ||
1248 | default: | ||
1249 | /* displayable characters */ | ||
1250 | buf[0] = key; | ||
1251 | buf[1] = '\0'; | ||
1252 | kn = buf; | ||
1253 | ks = buf; | ||
1254 | kc = buf; | ||
1255 | break; | ||
1256 | } | ||
1257 | *keyname = strdup(kn); | ||
1258 | if (!*keyname) return 0; | ||
1259 | *keysymbol = strdup(ks); | ||
1260 | if (!*keysymbol) | ||
1261 | { | ||
1262 | free(*keyname); | ||
1263 | *keyname = NULL; | ||
1264 | return 0; | ||
1265 | } | ||
1266 | *keycompose = strdup(kc); | ||
1267 | if (!*keycompose) | ||
1268 | { | ||
1269 | free(*keyname); | ||
1270 | free(*keysymbol); | ||
1271 | *keyname = NULL; | ||
1272 | *keysymbol = NULL; | ||
1273 | return 0; | ||
1274 | } | ||
1275 | |||
1276 | res = GetAsyncKeyState(VK_SHIFT); | ||
1277 | if (res & 0x8000) | ||
1278 | *modifiers |= ECORE_EVENT_MODIFIER_SHIFT; | ||
1279 | else | ||
1280 | *modifiers &= ~ECORE_EVENT_MODIFIER_SHIFT; | ||
1281 | |||
1282 | res = GetKeyState(VK_CONTROL); | ||
1283 | if (res & 0x8000) | ||
1284 | *modifiers |= ECORE_EVENT_MODIFIER_CTRL; | ||
1285 | else | ||
1286 | *modifiers &= ~ECORE_EVENT_MODIFIER_CTRL; | ||
1287 | |||
1288 | res = GetKeyState(VK_MENU); | ||
1289 | if (res & 0x8000) | ||
1290 | *modifiers |= ECORE_EVENT_MODIFIER_ALT; | ||
1291 | else | ||
1292 | *modifiers &= ~ECORE_EVENT_MODIFIER_ALT; | ||
1293 | |||
1294 | return 1; | ||
1295 | } | ||