aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/ecore/src/lib/ecore_win32/ecore_win32.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/ecore/src/lib/ecore_win32/ecore_win32.c')
-rw-r--r--libraries/ecore/src/lib/ecore_win32/ecore_win32.c841
1 files changed, 0 insertions, 841 deletions
diff --git a/libraries/ecore/src/lib/ecore_win32/ecore_win32.c b/libraries/ecore/src/lib/ecore_win32/ecore_win32.c
deleted file mode 100644
index b571d74..0000000
--- a/libraries/ecore/src/lib/ecore_win32/ecore_win32.c
+++ /dev/null
@@ -1,841 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include <config.h>
3#endif
4
5#include <stdlib.h>
6
7#define WIN32_LEAN_AND_MEAN
8#include <windows.h>
9#undef WIN32_LEAN_AND_MEAN
10#include <windowsx.h>
11
12#include <Eina.h>
13#include <Ecore.h>
14#include <Ecore_Input.h>
15
16#include "Ecore_Win32.h"
17#include "ecore_win32_private.h"
18
19/*============================================================================*
20 * Local *
21 *============================================================================*/
22
23/**
24 * @cond LOCAL
25 */
26
27/* OLE IID for Drag'n Drop */
28
29# define INITGUID
30# include <basetyps.h>
31DEFINE_OLEGUID(IID_IEnumFORMATETC, 0x00000103L, 0, 0);
32DEFINE_OLEGUID(IID_IDataObject, 0x0000010EL, 0, 0);
33DEFINE_OLEGUID(IID_IDropSource, 0x00000121L, 0, 0);
34DEFINE_OLEGUID(IID_IDropTarget, 0x00000122L, 0, 0);
35DEFINE_OLEGUID(IID_IUnknown, 0x00000000L, 0, 0);
36
37#define IDI_ICON 101
38
39static int _ecore_win32_init_count = 0;
40
41static void
42_ecore_win32_size_check(Ecore_Win32_Window *win, int w, int h, int *dx, int *dy)
43{
44 int minimal_width;
45 int minimal_height;
46
47 minimal_width = GetSystemMetrics(SM_CXMIN);
48 minimal_height = GetSystemMetrics(SM_CYMIN);
49 if ((w) < MAX(minimal_width, (int)win->min_width))
50 *dx = 0;
51 if ((w) > (int)win->max_width)
52 *dx = 0;
53 if ((h) < MAX(minimal_height, (int)win->min_height))
54 *dy = 0;
55 if ((h) > (int)win->max_height)
56 *dy = 0;
57}
58
59LRESULT CALLBACK
60_ecore_win32_window_procedure(HWND window,
61 UINT message,
62 WPARAM window_param,
63 LPARAM data_param)
64{
65 Ecore_Win32_Callback_Data *data;
66 POINTS point;
67 DWORD coord;
68
69 data = (Ecore_Win32_Callback_Data *)malloc(sizeof(Ecore_Win32_Callback_Data));
70 if (!data) return DefWindowProc(window, message, window_param, data_param);
71
72 data->window = window;
73 data->message = message;
74 data->window_param = window_param;
75 data->data_param = data_param;
76 data->timestamp = GetMessageTime();
77 coord = GetMessagePos();
78 point = MAKEPOINTS(coord);
79 data->x = point.x;
80 data->y = point.y;
81 data->discard_ctrl = EINA_FALSE;
82
83 switch (data->message)
84 {
85 /* Keyboard input notifications */
86 case WM_KEYDOWN:
87 case WM_SYSKEYDOWN:
88 if ((data->message == WM_KEYDOWN) &&
89 (data->window_param == VK_CONTROL) &&
90 ((HIWORD(data->data_param) & KF_EXTENDED) == 0))
91 {
92 /* Ctrl left key is pressed */
93 BOOL res;
94 MSG next_msg;
95
96 /*
97 * we check if the next message
98 * - is a WM_KEYDOWN
99 * - has the same timestamp than the Ctrl one
100 * - is the key press of the right Alt key
101 */
102 res = PeekMessage(&next_msg, data->window,
103 WM_KEYDOWN, WM_KEYDOWN,
104 PM_NOREMOVE);
105 if (res &&
106 (next_msg.wParam == VK_MENU) &&
107 (next_msg.time == data->timestamp) &&
108 (HIWORD(next_msg.lParam) & KF_EXTENDED))
109 {
110 INF("discard left Ctrl key press (sent by AltGr key press)");
111 data->discard_ctrl = EINA_TRUE;
112 }
113 }
114 _ecore_win32_event_handle_key_press(data, 1);
115 return 0;
116 case WM_CHAR:
117 case WM_SYSCHAR:
118 INF("char message");
119 _ecore_win32_event_handle_key_press(data, 0);
120 return 0;
121 case WM_KEYUP:
122 case WM_SYSKEYUP:
123 INF("keyup message");
124 if ((data->window_param == VK_CONTROL) &&
125 ((HIWORD(data->data_param) & KF_EXTENDED) == 0))
126 {
127 /* Ctrl left key is pressed */
128 BOOL res;
129 MSG next_msg;
130
131 /*
132 * we check if the next message
133 * - is a WM_KEYUP or WM_SYSKEYUP
134 * - has the same timestamp than the Ctrl one
135 * - is the key release of the right Alt key
136 */
137 res = PeekMessage(&next_msg, data->window,
138 WM_KEYUP, WM_SYSKEYUP,
139 PM_NOREMOVE);
140 if (res &&
141 ((next_msg.message == WM_KEYUP) ||
142 (next_msg.message == WM_SYSKEYUP)) &&
143 (next_msg.wParam == VK_MENU) &&
144 (next_msg.time == data->timestamp) &&
145 (HIWORD(next_msg.lParam) & KF_EXTENDED))
146 {
147 INF("discard left Ctrl key release (sent by AltGr key release)");
148 data->discard_ctrl = EINA_TRUE;
149 }
150 }
151 _ecore_win32_event_handle_key_release(data);
152 return 0;
153 case WM_SETFOCUS:
154 INF("setfocus message");
155 _ecore_win32_event_handle_focus_in(data);
156 return 0;
157 case WM_KILLFOCUS:
158 INF("kill focus message");
159 _ecore_win32_event_handle_focus_out(data);
160 return 0;
161 /* Mouse input notifications */
162 case WM_LBUTTONDOWN:
163 INF("left button down message");
164 SetCapture(window);
165 _ecore_win32_event_handle_button_press(data, 1);
166 return 0;
167 case WM_MBUTTONDOWN:
168 INF("middle button down message");
169 _ecore_win32_event_handle_button_press(data, 2);
170 return 0;
171 case WM_RBUTTONDOWN:
172 INF("right button down message");
173 _ecore_win32_event_handle_button_press(data, 3);
174 return 0;
175 case WM_LBUTTONUP:
176 {
177 Ecore_Win32_Window *w = NULL;
178
179 INF("left button up message");
180
181 ReleaseCapture();
182 w = (Ecore_Win32_Window *)GetWindowLongPtr(window, GWLP_USERDATA);
183 if (w->drag.dragging)
184 {
185 w->drag.dragging = 0;
186 return 0;
187 }
188
189 _ecore_win32_event_handle_button_release(data, 1);
190 return 0;
191 }
192 case WM_MBUTTONUP:
193 INF("middle button up message");
194 _ecore_win32_event_handle_button_release(data, 2);
195 return 0;
196 case WM_RBUTTONUP:
197 INF("right button up message");
198 _ecore_win32_event_handle_button_release(data, 3);
199 return 0;
200 case WM_MOUSEMOVE:
201 {
202 RECT rect;
203 Ecore_Win32_Window *w = NULL;
204
205 INF("moue move message");
206
207 w = (Ecore_Win32_Window *)GetWindowLongPtr(window, GWLP_USERDATA);
208
209 if (w->drag.dragging)
210 {
211 POINT pt;
212
213 pt.x = GET_X_LPARAM(data_param);
214 pt.y = GET_Y_LPARAM(data_param);
215 if (ClientToScreen(window, &pt))
216 {
217 if (w->drag.type == HTCAPTION)
218 {
219 int dx;
220 int dy;
221
222 dx = pt.x - w->drag.px;
223 dy = pt.y - w->drag.py;
224 ecore_win32_window_move(w, w->drag.x + dx, w->drag.y + dy);
225 w->drag.x += dx;
226 w->drag.y += dy;
227 w->drag.px = pt.x;
228 w->drag.py = pt.y;
229 return 0;
230 }
231 if (w->drag.type == HTLEFT)
232 {
233 int dw;
234
235 dw = pt.x - w->drag.px;
236 ecore_win32_window_move_resize(w, w->drag.x + dw, w->drag.y, w->drag.w - dw, w->drag.h);
237 w->drag.x += dw;
238 w->drag.w -= dw;
239 w->drag.px = pt.x;
240 w->drag.py = pt.y;
241 return 0;
242 }
243 if (w->drag.type == HTRIGHT)
244 {
245 int dw;
246
247 dw = pt.x - w->drag.px;
248 ecore_win32_window_resize(w, w->drag.w + dw, w->drag.h);
249 w->drag.w += dw;
250 w->drag.px = pt.x;
251 w->drag.py = pt.y;
252 return 0;
253 }
254 if (w->drag.type == HTTOP)
255 {
256 int dh;
257
258 dh = pt.y - w->drag.py;
259 ecore_win32_window_move_resize(w, w->drag.x, w->drag.y + dh, w->drag.w, w->drag.h - dh);
260 w->drag.y += dh;
261 w->drag.h -= dh;
262 w->drag.px = pt.x;
263 w->drag.py = pt.y;
264 return 0;
265 }
266 if (w->drag.type == HTBOTTOM)
267 {
268 int dh;
269
270 dh = pt.y - w->drag.py;
271 ecore_win32_window_resize(w, w->drag.w, w->drag.h + dh);
272 w->drag.h += dh;
273 w->drag.px = pt.x;
274 w->drag.py = pt.y;
275 return 0;
276 }
277 if (w->drag.type == HTTOPLEFT)
278 {
279 int dx;
280 int dy;
281 int dh;
282 int dw;
283
284 dw = pt.x - w->drag.px;
285 dh = pt.y - w->drag.py;
286 dx = dw;
287 dy = dh;
288 _ecore_win32_size_check(w,
289 w->drag.w - dw, w->drag.h - dh,
290 &dx, &dy);
291
292 ecore_win32_window_move_resize(w, w->drag.x + dx, w->drag.y + dy, w->drag.w - dw, w->drag.h - dh);
293 w->drag.x += dx;
294 w->drag.y += dy;
295 w->drag.w -= dw;
296 w->drag.h -= dh;
297 w->drag.px = pt.x;
298 w->drag.py = pt.y;
299 return 0;
300 }
301 if (w->drag.type == HTTOPRIGHT)
302 {
303 int dx;
304 int dy;
305 int dh;
306 int dw;
307
308 dw = pt.x - w->drag.px;
309 dh = pt.y - w->drag.py;
310 dx = dw;
311 dy = dh;
312 _ecore_win32_size_check(w,
313 w->drag.w, w->drag.h - dh,
314 &dx, &dy);
315 ecore_win32_window_move_resize(w, w->drag.x, w->drag.y + dy, w->drag.w, w->drag.h - dh);
316 w->drag.y += dy;
317 w->drag.w += dw;
318 w->drag.h -= dh;
319 w->drag.px = pt.x;
320 w->drag.py = pt.y;
321 return 0;
322 }
323 if (w->drag.type == HTBOTTOMLEFT)
324 {
325 int dx;
326 int dy;
327 int dh;
328 int dw;
329
330 dw = pt.x - w->drag.px;
331 dh = pt.y - w->drag.py;
332 dx = dw;
333 dy = dh;
334 _ecore_win32_size_check(w,
335 w->drag.w - dw, w->drag.h + dh,
336 &dx, &dy);
337 ecore_win32_window_move_resize(w, w->drag.x + dx, w->drag.y, w->drag.w - dw, w->drag.h + dh);
338 w->drag.x += dx;
339 w->drag.w -= dw;
340 w->drag.h += dh;
341 w->drag.px = pt.x;
342 w->drag.py = pt.y;
343 return 0;
344 }
345 if (w->drag.type == HTBOTTOMRIGHT)
346 {
347 int dh;
348 int dw;
349
350 dw = pt.x - w->drag.px;
351 dh = pt.y - w->drag.py;
352 ecore_win32_window_resize(w, w->drag.w + dw, w->drag.h + dh);
353 w->drag.w += dw;
354 w->drag.h += dh;
355 w->drag.px = pt.x;
356 w->drag.py = pt.y;
357 return 0;
358 }
359 }
360 }
361
362 if (GetClientRect(window, &rect))
363 {
364 POINT pt;
365
366 INF("mouse in window");
367
368 pt.x = GET_X_LPARAM(data_param);
369 pt.y = GET_Y_LPARAM(data_param);
370 if (!PtInRect(&rect, pt))
371 {
372 if (w->pointer_is_in)
373 {
374 w->pointer_is_in = 0;
375 _ecore_win32_event_handle_leave_notify(data);
376 }
377 }
378 else
379 {
380 if (!w->pointer_is_in)
381 {
382 w->pointer_is_in = 1;
383 _ecore_win32_event_handle_enter_notify(data);
384 }
385 }
386 }
387 else
388 {
389 ERR("GetClientRect() failed");
390 }
391 _ecore_win32_event_handle_motion_notify(data);
392
393 return 0;
394 }
395 case WM_MOUSEWHEEL:
396 INF("mouse wheel message");
397 _ecore_win32_event_handle_button_press(data, 4);
398 return 0;
399 /* Window notifications */
400 case WM_CREATE:
401 INF("create window message");
402 _ecore_win32_event_handle_create_notify(data);
403 return 0;
404 case WM_DESTROY:
405 INF("destroy window message");
406 _ecore_win32_event_handle_destroy_notify(data);
407 return 0;
408 case WM_SHOWWINDOW:
409 INF("show window message");
410 if ((data->data_param == SW_OTHERUNZOOM) ||
411 (data->data_param == SW_OTHERZOOM))
412 return 0;
413
414 if (data->window_param)
415 _ecore_win32_event_handle_map_notify(data);
416 else
417 _ecore_win32_event_handle_unmap_notify(data);
418
419 return 0;
420 case WM_CLOSE:
421 INF("close window message");
422 _ecore_win32_event_handle_delete_request(data);
423 return 0;
424 case WM_GETMINMAXINFO:
425 INF("get min max info window message");
426 return TRUE;
427 case WM_MOVING:
428 INF("moving window message");
429 _ecore_win32_event_handle_configure_notify(data);
430 return TRUE;
431 case WM_MOVE:
432 INF("move window message");
433 return 0;
434 case WM_SIZING:
435 INF("sizing window message");
436 _ecore_win32_event_handle_resize(data);
437 _ecore_win32_event_handle_configure_notify(data);
438 return TRUE;
439 case WM_SIZE:
440 INF("size window message");
441 return 0;
442/* case WM_WINDOWPOSCHANGING: */
443/* { */
444/* RECT rect; */
445/* GetClientRect(window, &rect); */
446/* printf (" *** ecore message : WINDOWPOSCHANGING %ld %ld\n", */
447/* rect.right - rect.left, rect.bottom - rect.top); */
448/* } */
449/* _ecore_win32_event_handle_configure_notify(data); */
450/* return 0; */
451 case WM_WINDOWPOSCHANGED:
452 INF("position changed window message");
453 _ecore_win32_event_handle_configure_notify(data);
454 _ecore_win32_event_handle_expose(data);
455 return 0;
456 case WM_ENTERSIZEMOVE:
457 INF("enter size move window message");
458 return 0;
459 case WM_EXITSIZEMOVE:
460 INF("exit size move window message");
461 return 0;
462 case WM_NCLBUTTONDOWN:
463 INF("non client left button down window message");
464
465 if (((DWORD)window_param == HTCAPTION) ||
466 ((DWORD)window_param == HTBOTTOM) ||
467 ((DWORD)window_param == HTBOTTOMLEFT) ||
468 ((DWORD)window_param == HTBOTTOMRIGHT) ||
469 ((DWORD)window_param == HTLEFT) ||
470 ((DWORD)window_param == HTRIGHT) ||
471 ((DWORD)window_param == HTTOP) ||
472 ((DWORD)window_param == HTTOPLEFT) ||
473 ((DWORD)window_param == HTTOPRIGHT))
474 {
475 Ecore_Win32_Window *w;
476
477 w = (Ecore_Win32_Window *)GetWindowLongPtr(window, GWLP_USERDATA);
478 ecore_win32_window_geometry_get(w,
479 NULL, NULL,
480 &w->drag.w, &w->drag.h);
481 SetCapture(window);
482 w->drag.type = (DWORD)window_param;
483 w->drag.px = GET_X_LPARAM(data_param);
484 w->drag.py = GET_Y_LPARAM(data_param);
485 w->drag.dragging = 1;
486 return 0;
487 }
488 return DefWindowProc(window, message, window_param, data_param);
489 case WM_SYSCOMMAND:
490 INF("sys command window message %d", (int)window_param);
491
492 if ((((DWORD)window_param & 0xfff0) == SC_MOVE) ||
493 (((DWORD)window_param & 0xfff0) == SC_SIZE))
494 {
495 Ecore_Win32_Window *w;
496
497 INF("sys command MOVE or SIZE window message : %dx%d", GET_X_LPARAM(data_param), GET_Y_LPARAM(data_param));
498
499 w = (Ecore_Win32_Window *)GetWindowLongPtr(window, GWLP_USERDATA);
500 w->drag.dragging = 1;
501 return 0;
502 }
503 return DefWindowProc(window, message, window_param, data_param);
504 /* GDI notifications */
505 case WM_ERASEBKGND:
506 return 1;
507 case WM_PAINT:
508 {
509 RECT rect;
510
511 INF("paint message");
512
513 if (GetUpdateRect(window, &rect, FALSE))
514 {
515 PAINTSTRUCT ps;
516 HDC hdc;
517
518 hdc = BeginPaint(window, &ps);
519 data->update = rect;
520 _ecore_win32_event_handle_expose(data);
521 EndPaint(window, &ps);
522 }
523 return 0;
524 }
525 case WM_SETREDRAW:
526 INF("set redraw message");
527 return 0;
528 case WM_SYNCPAINT:
529 INF("sync paint message");
530 return 0;
531 default:
532 return DefWindowProc(window, message, window_param, data_param);
533 }
534}
535
536/**
537 * @endcond
538 */
539
540
541/*============================================================================*
542 * Global *
543 *============================================================================*/
544
545
546HINSTANCE _ecore_win32_instance = NULL;
547double _ecore_win32_double_click_time = 0.25;
548unsigned long _ecore_win32_event_last_time = 0;
549Ecore_Win32_Window *_ecore_win32_event_last_window = NULL;
550int _ecore_win32_log_dom_global = -1;
551
552int ECORE_WIN32_EVENT_MOUSE_IN = 0;
553int ECORE_WIN32_EVENT_MOUSE_OUT = 0;
554int ECORE_WIN32_EVENT_WINDOW_FOCUS_IN = 0;
555int ECORE_WIN32_EVENT_WINDOW_FOCUS_OUT = 0;
556int ECORE_WIN32_EVENT_WINDOW_DAMAGE = 0;
557int ECORE_WIN32_EVENT_WINDOW_CREATE = 0;
558int ECORE_WIN32_EVENT_WINDOW_DESTROY = 0;
559int ECORE_WIN32_EVENT_WINDOW_SHOW = 0;
560int ECORE_WIN32_EVENT_WINDOW_HIDE = 0;
561int ECORE_WIN32_EVENT_WINDOW_CONFIGURE = 0;
562int ECORE_WIN32_EVENT_WINDOW_RESIZE = 0;
563int ECORE_WIN32_EVENT_WINDOW_DELETE_REQUEST = 0;
564
565/*============================================================================*
566 * API *
567 *============================================================================*/
568
569/**
570 * @addtogroup Ecore_Win32_Group Ecore_Win32 library
571 *
572 * Ecore_Win32 is a library that wraps Windows graphic functions
573 * and integrate them nicely into the Ecore main loop.
574 *
575 * @section Ecore_Win32_Sec_Init Initialisation / Shutdown
576 *
577 * To fill...
578 *
579 * @section Ecore_Win32_Sec_Icons How to set icons to an application
580 *
581 * It is possible to also sets the icon of the application easily:
582 *
583 * @li Create an icon with your favorite image creator. The Gimp is a
584 * good choice. Create several images of size 16, 32 and 48. You can
585 * also create images of size 24, 64, 128 and 256. Paste all of them
586 * in the image of size 16 as a layer. Save the image of size 16 with
587 * the name my_icon.ico. Put it where the source code of the
588 * application is located.
589 * @li Create my_icon_rc.rc file with your code editor and add in it:
590 * @code
591 * 101 ICON DISCARDABLE "my_icon.ico"
592 * @endcode
593 * @li With Visual Studio, put that file in the 'Resource file' part
594 * of the project.
595 * @li With MinGW, you have to compile it with windres:
596 * @code
597 * windres my_icon_rc.rc my_icon_rc.o
598 * @endcode
599 * and add my_icon_rc.o to the object files of the application.
600 *
601 * @note The value 101 must not be changed, it's the ID used
602 * internally by Ecore_Win32 to get the icons.
603 *
604 * @{
605 */
606
607/**
608 * @brief Initialize the Ecore_Win32 library.
609 *
610 * @return 1 or greater on success, 0 on error.
611 *
612 * This function sets up the Windows graphic system. It returns 0 on
613 * failure, otherwise it returns the number of times it has already been
614 * called.
615 *
616 * When Ecore_Win32 is not used anymore, call ecore_win32_shutdown()
617 * to shut down the Ecore_Win32 library.
618 */
619EAPI int
620ecore_win32_init()
621{
622 WNDCLASSEX wc;
623 HICON icon;
624 HICON icon_sm;
625
626 if (++_ecore_win32_init_count != 1)
627 return _ecore_win32_init_count;
628
629 if (!eina_init())
630 return --_ecore_win32_init_count;
631
632 _ecore_win32_log_dom_global = eina_log_domain_register
633 ("ecore_win32", ECORE_WIN32_DEFAULT_LOG_COLOR);
634 if (_ecore_win32_log_dom_global < 0)
635 {
636 EINA_LOG_ERR("Ecore_Win32: Could not register log domain");
637 goto shutdown_eina;
638 }
639
640 if (!ecore_event_init())
641 {
642 ERR("Ecore_Win32: Could not init ecore_event");
643 goto unregister_log_domain;
644 }
645
646 _ecore_win32_instance = GetModuleHandle(NULL);
647 if (!_ecore_win32_instance)
648 {
649 ERR("GetModuleHandle() failed");
650 goto shutdown_ecore_event;
651 }
652
653 icon = LoadImage(_ecore_win32_instance,
654 MAKEINTRESOURCE(IDI_ICON),
655 IMAGE_ICON,
656 GetSystemMetrics(SM_CXICON),
657 GetSystemMetrics(SM_CYICON),
658 LR_DEFAULTCOLOR);
659 icon_sm = LoadImage(_ecore_win32_instance,
660 MAKEINTRESOURCE(IDI_ICON),
661 IMAGE_ICON,
662 GetSystemMetrics(SM_CXSMICON),
663 GetSystemMetrics(SM_CYSMICON),
664 LR_DEFAULTCOLOR);
665 if (!icon)
666 icon = LoadIcon (NULL, IDI_APPLICATION);
667 if (!icon_sm)
668 icon_sm = LoadIcon (NULL, IDI_APPLICATION);
669
670 memset (&wc, 0, sizeof (WNDCLASSEX));
671 wc.cbSize = sizeof (WNDCLASSEX);
672 wc.style = CS_HREDRAW | CS_VREDRAW;
673 wc.lpfnWndProc = _ecore_win32_window_procedure;
674 wc.cbClsExtra = 0;
675 wc.cbWndExtra = 0;
676 wc.hInstance = _ecore_win32_instance;
677 wc.hIcon = icon;
678 wc.hCursor = LoadCursor (NULL, IDC_ARROW);
679 wc.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE);
680 wc.lpszMenuName = NULL;
681 wc.lpszClassName = ECORE_WIN32_WINDOW_CLASS;
682 wc.hIconSm = icon_sm;
683
684 if(!RegisterClassEx(&wc))
685 {
686 ERR("RegisterClass() failed");
687 goto free_library;
688 }
689
690 if (!ecore_win32_dnd_init())
691 {
692 ERR("ecore_win32_dnd_init() failed");
693 goto unregister_class;
694 }
695
696 if (!ECORE_WIN32_EVENT_MOUSE_IN)
697 {
698 ECORE_WIN32_EVENT_MOUSE_IN = ecore_event_type_new();
699 ECORE_WIN32_EVENT_MOUSE_OUT = ecore_event_type_new();
700 ECORE_WIN32_EVENT_WINDOW_FOCUS_IN = ecore_event_type_new();
701 ECORE_WIN32_EVENT_WINDOW_FOCUS_OUT = ecore_event_type_new();
702 ECORE_WIN32_EVENT_WINDOW_DAMAGE = ecore_event_type_new();
703 ECORE_WIN32_EVENT_WINDOW_CREATE = ecore_event_type_new();
704 ECORE_WIN32_EVENT_WINDOW_DESTROY = ecore_event_type_new();
705 ECORE_WIN32_EVENT_WINDOW_SHOW = ecore_event_type_new();
706 ECORE_WIN32_EVENT_WINDOW_HIDE = ecore_event_type_new();
707 ECORE_WIN32_EVENT_WINDOW_CONFIGURE = ecore_event_type_new();
708 ECORE_WIN32_EVENT_WINDOW_RESIZE = ecore_event_type_new();
709 ECORE_WIN32_EVENT_WINDOW_DELETE_REQUEST = ecore_event_type_new();
710 }
711
712 return _ecore_win32_init_count;
713
714 unregister_class:
715 UnregisterClass(ECORE_WIN32_WINDOW_CLASS, _ecore_win32_instance);
716 free_library:
717 FreeLibrary(_ecore_win32_instance);
718 shutdown_ecore_event:
719 ecore_event_shutdown();
720 unregister_log_domain:
721 eina_log_domain_unregister(_ecore_win32_log_dom_global);
722 shutdown_eina:
723 eina_shutdown();
724
725 return --_ecore_win32_init_count;
726}
727
728/**
729 * @brief Shut down the Ecore_Win32 library.
730 *
731 * @return 0 when the library is completely shut down, 1 or
732 * greater otherwise.
733 *
734 * This function shuts down the Ecore_Win32 library. It returns 0 when it has
735 * been called the same number of times than ecore_win32_init(). In that case
736 * it shuts down all the Windows graphic system.
737 */
738EAPI int
739ecore_win32_shutdown()
740{
741 if (--_ecore_win32_init_count != 0)
742 return _ecore_win32_init_count;
743
744 ecore_win32_dnd_shutdown();
745
746 if (!UnregisterClass(ECORE_WIN32_WINDOW_CLASS, _ecore_win32_instance))
747 INF("UnregisterClass() failed");
748
749 if (!FreeLibrary(_ecore_win32_instance))
750 INF("FreeLibrary() failed");
751
752 _ecore_win32_instance = NULL;
753
754 ecore_event_shutdown();
755 eina_log_domain_unregister(_ecore_win32_log_dom_global);
756 _ecore_win32_log_dom_global = -1;
757 eina_shutdown();
758
759 return _ecore_win32_init_count;
760}
761
762/**
763 * @brief Retrieve the depth of the screen.
764 *
765 * @return The depth of the screen.
766 *
767 * This function returns the depth of the screen. If an error occurs,
768 * it returns 0.
769 */
770EAPI int
771ecore_win32_screen_depth_get()
772{
773 HDC dc;
774 int depth;
775
776 INF("getting screen depth");
777
778 dc = GetDC(NULL);
779 if (!dc)
780 {
781 ERR("GetDC() failed");
782 return 0;
783 }
784
785 depth = GetDeviceCaps(dc, BITSPIXEL);
786 if (!ReleaseDC(NULL, dc))
787 {
788 ERR("ReleaseDC() failed (device context not released)");
789 }
790
791 return depth;
792}
793
794/**
795 * @brief Sets the timeout for a double and triple clicks to be flagged.
796 *
797 * @param t The time in seconds.
798 *
799 * This function sets the time @p t between clicks before the
800 * double_click flag is set in a button down event. If 3 clicks occur
801 * within double this time, the triple_click flag is also set.
802 */
803EAPI void
804ecore_win32_double_click_time_set(double t)
805{
806 if (t < 0.0) t = 0.0;
807 _ecore_win32_double_click_time = t;
808}
809
810/**
811 * @brief Retrieve the double and triple click flag timeout.
812 *
813 * @return The timeout for double clicks in seconds.
814 *
815 * This function returns the double clicks in seconds. If
816 * ecore_win32_double_click_time_set() has not been called, the
817 * default value is returned. See ecore_win32_double_click_time_set()
818 * for more informations.
819 */
820EAPI double
821ecore_win32_double_click_time_get(void)
822{
823 return _ecore_win32_double_click_time;
824}
825
826/**
827 * @brief Return the last event time.
828 *
829 * @return The last envent time.
830 *
831 * This function returns the last event time.
832 */
833EAPI unsigned long
834ecore_win32_current_time_get(void)
835{
836 return _ecore_win32_event_last_time;
837}
838
839/**
840 * @}
841 */
generated by cgit v1.1 at 2024-07-18 03:57:00 +0000