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