1 /* GDK - The GIMP Drawing Kit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 * Copyright (C) 1998-1999 Tor Lillqvist
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the
17 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 * Boston, MA 02111-1307, USA.
22 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
23 * file for a list of people on the GTK+ Team. See the ChangeLog
24 * files for a list of changes. These files are distributed with
25 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
30 /* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message
31 * doesn't tell us where the mouse has gone. Thus we cannot use it to
32 * generate a correct GdkNotifyType. Pity, as using TrackMouseEvent
33 * otherwise would make it possible to reliably generate
34 * GDK_LEAVE_NOTIFY events, which would help get rid of those pesky
35 * tooltips sometimes popping up in the wrong place.
37 /* define USE_TRACKMOUSEEVENT */
39 /* Do use SetCapture, it works now. Thanks to jpe@archaeopteryx.com */
40 #define USE_SETCAPTURE 1
44 #include "gdkprivate-win32.h"
52 #include "surrogate-dimm.h"
56 #include "gdkinternals.h"
57 #include "gdkinput-win32.h"
59 #include "gdkkeysyms.h"
61 #define PING() printf("%s: %d\n",__FILE__,__LINE__),fflush(stdout)
63 typedef struct _GdkIOClosure GdkIOClosure;
64 typedef struct _GdkEventPrivate GdkEventPrivate;
68 /* Following flag is set for events on the event queue during
69 * translation and cleared afterwards.
71 GDK_EVENT_PENDING = 1 << 0
76 GdkInputFunction function;
77 GdkInputCondition condition;
78 GdkDestroyNotify notify;
82 struct _GdkEventPrivate
89 * Private function declarations
92 static GdkFilterReturn
93 gdk_event_apply_filters(MSG *msg,
96 static gboolean gdk_event_translate (GdkEvent *event,
98 gboolean *ret_val_flagp,
100 gboolean return_exposes);
102 static gboolean gdk_event_prepare (GSource *source,
104 static gboolean gdk_event_check (GSource *source);
105 static gboolean gdk_event_dispatch (GSource *source,
106 GSourceFunc callback,
109 /* Private variable declarations
112 static GdkWindow *p_grab_window = NULL; /* Window that currently
113 * holds the pointer grab
116 static GdkWindow *k_grab_window = NULL; /* Window the holds the
120 static GList *client_filters; /* Filters for client messages */
122 static gboolean p_grab_automatic;
123 static GdkEventMask p_grab_mask;
124 static gboolean p_grab_owner_events, k_grab_owner_events;
125 static HCURSOR p_grab_cursor;
127 static GSourceFuncs event_funcs = {
134 GPollFD event_poll_fd;
136 static GdkWindow *current_window = NULL;
137 static gint current_x, current_y;
138 static gdouble current_x_root, current_y_root;
139 static UINT gdk_ping_msg;
140 static UINT msh_mousewheel_msg;
141 static gboolean ignore_wm_char = FALSE;
142 static gboolean is_altgr_key = FALSE;
144 static IActiveIMMApp *active_imm_app = NULL;
145 static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
147 typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
148 static PFN_TrackMouseEvent track_mouse_event = NULL;
150 static gboolean use_ime_composition = FALSE;
153 real_window_procedure (HWND hwnd,
158 GdkEventPrivate event;
164 gboolean ret_val_flag;
167 msg.message = message;
170 msg.time = GetTickCount ();
171 pos = GetMessagePos ();
172 msg.pt.x = LOWORD (pos);
173 msg.pt.y = HIWORD (pos);
175 event.flags = GDK_EVENT_PENDING;
176 if (gdk_event_translate (&event.event, &msg, &ret_val_flag, &ret_val, FALSE))
178 event.flags &= ~GDK_EVENT_PENDING;
180 if (event.event.any.type == GDK_CONFIGURE)
182 /* Compress configure events */
183 GList *list = gdk_queued_events;
186 && (((GdkEvent *)list->data)->any.type != GDK_CONFIGURE
187 || ((GdkEvent *)list->data)->any.window != event.event.any.window))
191 GDK_NOTE (EVENTS, g_print ("... compressing an CONFIGURE event\n"));
193 *((GdkEvent *)list->data) = event.event;
194 gdk_drawable_unref (event.event.any.window);
195 /* Wake up WaitMessage */
196 PostMessage (NULL, gdk_ping_msg, 0, 0);
200 else if (event.event.any.type == GDK_EXPOSE)
202 /* Compress expose events */
203 GList *list = gdk_queued_events;
206 && (((GdkEvent *)list->data)->any.type != GDK_EXPOSE
207 || ((GdkEvent *)list->data)->any.window != event.event.any.window))
213 GDK_NOTE (EVENTS, g_print ("... compressing an EXPOSE event\n"));
214 gdk_rectangle_union (&event.event.expose.area,
215 &((GdkEvent *)list->data)->expose.area,
217 ((GdkEvent *)list->data)->expose.area = u;
218 gdk_drawable_unref (event.event.any.window);
220 /* Wake up WaitMessage */
221 PostMessage (NULL, gdk_ping_msg, 0, 0);
227 eventp = gdk_event_new ();
228 *((GdkEventPrivate *) eventp) = event;
230 /* Philippe Colantoni <colanton@aris.ss.uci.edu> suggests this
231 * in order to handle events while opaque resizing neatly. I
232 * don't want it as default. Set the
233 * GDK_EVENT_FUNC_FROM_WINDOW_PROC env var to get this
236 if (gdk_event_func_from_window_proc && gdk_event_func)
238 GDK_THREADS_ENTER ();
240 (*gdk_event_func) (eventp, gdk_event_data);
241 gdk_event_free (eventp);
243 GDK_THREADS_LEAVE ();
247 gdk_event_queue_append (eventp);
249 /* Wake up WaitMessage */
250 PostMessage (NULL, gdk_ping_msg, 0, 0);
264 if (active_imm_app == NULL
265 || (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
266 return DefWindowProc (hwnd, message, wparam, lparam);
273 gdk_window_procedure (HWND hwnd,
280 GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx %s\n",
281 (gulong) hwnd, gdk_win32_message_name (message)));
283 retval = real_window_procedure (hwnd, message, wparam, lparam);
285 GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx returns %ld\n",
286 (gulong) hwnd, retval));
292 gdk_events_init (void)
296 #ifdef USE_TRACKMOUSEEVENT
297 HMODULE user32, imm32;
298 HINSTANCE commctrl32;
301 gdk_ping_msg = RegisterWindowMessage ("gdk-ping");
302 GDK_NOTE (EVENTS, g_print ("gdk-ping = %#x\n", gdk_ping_msg));
304 /* This is the string MSH_MOUSEWHEEL from zmouse.h,
305 * http://www.microsoft.com/mouse/intellimouse/sdk/zmouse.h
306 * This message is used by mouse drivers than cannot generate WM_MOUSEWHEEL
309 msh_mousewheel_msg = RegisterWindowMessage ("MSWHEEL_ROLLMSG");
310 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL = %#x\n", msh_mousewheel_msg));
312 source = g_source_new (&event_funcs, sizeof (GSource));
313 g_source_set_priority (source, GDK_PRIORITY_EVENTS);
315 event_poll_fd.fd = G_WIN32_MSG_HANDLE;
316 event_poll_fd.events = G_IO_IN;
318 g_source_add_poll (source, &event_poll_fd);
319 g_source_set_can_recurse (source, TRUE);
320 g_source_attach (source, NULL);
322 hres = CoCreateInstance (&CLSID_CActiveIMM,
326 (LPVOID *) &active_imm_app);
330 GDK_NOTE (EVENTS, g_print ("IActiveIMMApp created %p\n",
332 (*active_imm_app->lpVtbl->Activate) (active_imm_app, TRUE);
334 hres = (*active_imm_app->lpVtbl->QueryInterface) (active_imm_app, &IID_IActiveIMMMessagePumpOwner, &active_imm_msgpump_owner);
335 GDK_NOTE (EVENTS, g_print ("IActiveIMMMessagePumpOwner created %p\n",
336 active_imm_msgpump_owner));
337 (active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
340 #ifdef USE_TRACKMOUSEEVENT
341 user32 = GetModuleHandle ("user32.dll");
342 if ((track_mouse_event = GetProcAddress (user32, "TrackMouseEvent")) == NULL)
344 if ((commctrl32 = LoadLibrary ("commctrl32.dll")) != NULL)
345 track_mouse_event = (PFN_TrackMouseEvent)
346 GetProcAddress (commctrl32, "_TrackMouseEvent");
348 if (track_mouse_event != NULL)
349 GDK_NOTE (EVENTS, g_print ("Using TrackMouseEvent to detect leave events\n"));
351 if (IS_WIN_NT () && (windows_version & 0xFF) == 5)
353 /* On Win2k (Beta 3, at least) WM_IME_CHAR doesn't seem to work
354 * correctly for non-Unicode applications. Handle
355 * WM_IME_COMPOSITION with GCS_RESULTSTR instead, fetch the
356 * Unicode char from the IME with ImmGetCompositionStringW().
358 use_ime_composition = TRUE;
363 *--------------------------------------------------------------
366 * Returns if events are pending on the queue.
371 * Returns TRUE if events are pending
375 *--------------------------------------------------------------
379 gdk_events_pending (void)
383 return (gdk_event_queue_find_first() ||
384 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
388 *--------------------------------------------------------------
389 * gdk_event_get_graphics_expose
391 * Waits for a GraphicsExpose or NoExpose event
396 * For GraphicsExpose events, returns a pointer to the event
397 * converted into a GdkEvent Otherwise, returns NULL.
401 *-------------------------------------------------------------- */
404 gdk_event_get_graphics_expose (GdkWindow *window)
409 g_return_val_if_fail (window != NULL, NULL);
411 GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));
414 /* Some nasty bugs here, just return NULL for now. */
417 if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
419 event = gdk_event_new ();
421 if (gdk_event_translate (event, &msg, NULL, NULL, TRUE))
424 gdk_event_free (event);
432 event_mask_string (GdkEventMask mask)
434 static char bfr[500];
439 if (mask & GDK_##x##_MASK) \
440 p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
443 BIT(POINTER_MOTION_HINT);
456 BIT(PROPERTY_CHANGE);
457 BIT(VISIBILITY_NOTIFY);
468 *--------------------------------------------------------------
471 * Grabs the pointer to a specific window
474 * "window" is the window which will receive the grab
475 * "owner_events" specifies whether events will be reported as is,
476 * or relative to "window"
477 * "event_mask" masks only interesting events
478 * "confine_to" limits the cursor movement to the specified window
479 * "cursor" changes the cursor for the duration of the grab
480 * "time" specifies the time
485 * requires a corresponding call to gdk_pointer_ungrab
487 *--------------------------------------------------------------
491 gdk_pointer_grab (GdkWindow *window,
492 gboolean owner_events,
493 GdkEventMask event_mask,
494 GdkWindow *confine_to,
498 HWND hwnd_confined_to;
500 GdkCursorPrivate *cursor_private;
503 g_return_val_if_fail (window != NULL, 0);
504 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
505 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
507 cursor_private = (GdkCursorPrivate*) cursor;
509 if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
510 hwnd_confined_to = NULL;
512 hwnd_confined_to = GDK_WINDOW_HWND (confine_to);
517 hcursor = cursor_private->hcursor;
519 return_val = _gdk_input_grab_pointer (window,
525 if (return_val == GDK_GRAB_SUCCESS)
527 if (!GDK_WINDOW_DESTROYED (window))
529 GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#lx %s %#lx %s\n",
530 (gulong) GDK_WINDOW_HWND (window),
531 (owner_events ? "TRUE" : "FALSE"),
533 event_mask_string (event_mask)));
534 p_grab_mask = event_mask;
535 p_grab_owner_events = (owner_events != 0);
536 p_grab_automatic = FALSE;
539 SetCapture (GDK_WINDOW_HWND (window));
541 return_val = GDK_GRAB_SUCCESS;
544 return_val = GDK_GRAB_ALREADY_GRABBED;
547 if (return_val == GDK_GRAB_SUCCESS)
549 p_grab_window = window;
550 p_grab_cursor = hcursor;
557 *--------------------------------------------------------------
560 * Releases any pointer grab
568 *--------------------------------------------------------------
572 gdk_pointer_ungrab (guint32 time)
574 GDK_NOTE (EVENTS, g_print ("gdk_pointer_ungrab\n"));
576 _gdk_input_ungrab_pointer (time);
579 if (GetCapture () != NULL)
583 p_grab_window = NULL;
587 *--------------------------------------------------------------
588 * find_window_for_pointer_event
590 * Find the window a pointer event (mouse up, down, move) should
591 * be reported to. If the return value != reported_window then
592 * the ref count of reported_window will be decremented and the
593 * ref count of the return value will be incremented.
597 * "reported_window" is the gdk window the xevent was reported relative to
598 * "xevent" is the win32 message
604 *--------------------------------------------------------------
608 find_window_for_pointer_event (GdkWindow* reported_window,
614 GdkWindow* other_window;
616 if (p_grab_window == NULL || !p_grab_owner_events)
617 return reported_window;
619 points = MAKEPOINTS (msg->lParam);
622 ClientToScreen (msg->hwnd, &pt);
624 GDK_NOTE (EVENTS, g_print ("Finding window for grabbed pointer event at (%ld, %ld)\n",
627 hwnd = WindowFromPoint (pt);
629 return reported_window;
630 other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
631 if (other_window == NULL)
632 return reported_window;
634 GDK_NOTE (EVENTS, g_print ("Found window %#x for point (%ld, %ld)\n",
635 (guint) hwnd, pt.x, pt.y));
637 gdk_window_unref (reported_window);
638 gdk_window_ref (other_window);
644 *--------------------------------------------------------------
645 * gdk_pointer_is_grabbed
647 * Tell wether there is an active x pointer grab in effect
655 *--------------------------------------------------------------
659 gdk_pointer_is_grabbed (void)
661 return p_grab_window != NULL;
665 *--------------------------------------------------------------
668 * Grabs the keyboard to a specific window
671 * "window" is the window which will receive the grab
672 * "owner_events" specifies whether events will be reported as is,
673 * or relative to "window"
674 * "time" specifies the time
679 * requires a corresponding call to gdk_keyboard_ungrab
681 *--------------------------------------------------------------
685 gdk_keyboard_grab (GdkWindow *window,
686 gboolean owner_events,
691 g_return_val_if_fail (window != NULL, 0);
692 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
694 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#lx\n",
695 (gulong) GDK_WINDOW_HWND (window)));
697 if (!GDK_WINDOW_DESTROYED (window))
699 k_grab_owner_events = owner_events != 0;
700 return_val = GDK_GRAB_SUCCESS;
703 return_val = GDK_GRAB_ALREADY_GRABBED;
705 if (return_val == GDK_GRAB_SUCCESS)
706 k_grab_window = window;
712 *--------------------------------------------------------------
713 * gdk_keyboard_ungrab
715 * Releases any keyboard grab
723 *--------------------------------------------------------------
727 gdk_keyboard_ungrab (guint32 time)
729 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));
731 k_grab_window = NULL;
734 static GdkFilterReturn
735 gdk_event_apply_filters (MSG *msg,
739 GdkEventFilter *filter;
741 GdkFilterReturn result;
747 filter = (GdkEventFilter *) tmp_list->data;
749 result = (*filter->function) (msg, event, filter->data);
750 if (result != GDK_FILTER_CONTINUE)
753 tmp_list = tmp_list->next;
756 return GDK_FILTER_CONTINUE;
760 gdk_add_client_message_filter (GdkAtom message_type,
764 GdkClientFilter *filter = g_new (GdkClientFilter, 1);
766 filter->type = message_type;
767 filter->function = func;
770 client_filters = g_list_prepend (client_filters, filter);
773 /* Thanks to Markus G. Kuhn <mkuhn@acm.org> for the ksysym<->Unicode
774 * mapping functions, from the xterm sources.
778 build_key_event_state (GdkEvent *event)
780 if (GetKeyState (VK_SHIFT) < 0)
781 event->key.state |= GDK_SHIFT_MASK;
782 if (GetKeyState (VK_CAPITAL) & 0x1)
783 event->key.state |= GDK_LOCK_MASK;
786 if (GetKeyState (VK_CONTROL) < 0)
788 event->key.state |= GDK_CONTROL_MASK;
790 if (event->key.keyval < ' ')
791 event->key.keyval += '@';
795 else if (event->key.keyval < ' ')
797 event->key.state |= GDK_CONTROL_MASK;
798 event->key.keyval += '@';
801 if (GetKeyState (VK_MENU) < 0)
802 event->key.state |= GDK_MOD1_MASK;
807 build_pointer_event_state (MSG *msg)
812 if (msg->wParam & MK_CONTROL)
813 state |= GDK_CONTROL_MASK;
814 if (msg->wParam & MK_LBUTTON)
815 state |= GDK_BUTTON1_MASK;
816 if (msg->wParam & MK_MBUTTON)
817 state |= GDK_BUTTON2_MASK;
818 if (msg->wParam & MK_RBUTTON)
819 state |= GDK_BUTTON3_MASK;
820 if (msg->wParam & MK_SHIFT)
821 state |= GDK_SHIFT_MASK;
822 if (GetKeyState (VK_MENU) < 0)
823 state |= GDK_MOD1_MASK;
824 if (GetKeyState (VK_CAPITAL) & 0x1)
825 state |= GDK_LOCK_MASK;
831 build_keypress_event (GdkWindowImplWin32 *impl,
836 gint i, bytecount, ucount, ucleft, len;
837 guchar buf[100], *bp;
838 wchar_t wbuf[100], *wcp;
840 event->key.type = GDK_KEY_PRESS;
841 event->key.time = msg->time;
842 event->key.state = 0;
844 if (msg->message == WM_IME_COMPOSITION)
846 himc = ImmGetContext (msg->hwnd);
848 bytecount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
849 wbuf, sizeof (wbuf));
850 ucount = bytecount / 2;
854 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
856 bytecount = MIN ((msg->lParam & 0xFFFF), sizeof (buf));
857 for (i = 0; i < bytecount; i++)
858 buf[i] = msg->wParam;
860 else /* WM_IME_CHAR */
862 event->key.keyval = GDK_VoidSymbol;
863 if (msg->wParam & 0xFF00)
865 /* Contrary to some versions of the documentation,
866 * the lead byte is the most significant byte.
868 buf[0] = ((msg->wParam >> 8) & 0xFF);
869 buf[1] = (msg->wParam & 0xFF);
874 buf[0] = (msg->wParam & 0xFF);
879 /* Convert from the window's current code page
880 * to Unicode. Then convert to UTF-8.
881 * We don't handle the surrogate stuff. Should we?
883 ucount = MultiByteToWideChar (impl->charset_info.ciACP,
885 wbuf, sizeof (wbuf) / sizeof (wbuf[0]));
889 event->key.keyval = GDK_VoidSymbol;
890 else if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
892 if (msg->wParam < ' ')
894 event->key.keyval = msg->wParam + '@';
895 /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
898 event->key.state |= GDK_CONTROL_MASK;
901 event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
904 build_key_event_state (event);
906 /* Build UTF-8 string */
922 event->key.string = g_malloc (len + 1);
923 event->key.length = len;
927 bp = event->key.string;
953 case 3: bp[2] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
954 case 2: bp[1] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
955 case 1: bp[0] = c | first;
958 for (i = len - 1; i > 0; --i)
960 bp[i] = (c & 0x3f) | 0x80;
972 build_keyrelease_event (GdkWindowImplWin32 *impl,
979 event->key.type = GDK_KEY_RELEASE;
980 event->key.time = msg->time;
981 event->key.state = 0;
983 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
984 if (msg->wParam < ' ')
985 event->key.keyval = msg->wParam + '@';
989 MultiByteToWideChar (impl->charset_info.ciACP,
990 0, &buf, 1, &wbuf, 1);
992 event->key.keyval = gdk_unicode_to_keyval (wbuf);
995 event->key.keyval = GDK_VoidSymbol;
996 build_key_event_state (event);
997 event->key.string = NULL;
998 event->key.length = 0;
1002 print_event_state (gint state)
1004 #define CASE(bit) if (state & GDK_ ## bit ## _MASK) g_print (#bit " ");
1016 print_window_state (GdkWindowState state)
1018 #define CASE(bit) if (state & GDK_WINDOW_STATE_ ## bit ) g_print (#bit " ");
1027 print_event (GdkEvent *event)
1029 gchar *escaped, *kvname;
1031 switch (event->any.type)
1033 #define CASE(x) case x: g_print ( #x " "); break;
1038 CASE (GDK_MOTION_NOTIFY);
1039 CASE (GDK_BUTTON_PRESS);
1040 CASE (GDK_2BUTTON_PRESS);
1041 CASE (GDK_3BUTTON_PRESS);
1042 CASE (GDK_BUTTON_RELEASE);
1043 CASE (GDK_KEY_PRESS);
1044 CASE (GDK_KEY_RELEASE);
1045 CASE (GDK_ENTER_NOTIFY);
1046 CASE (GDK_LEAVE_NOTIFY);
1047 CASE (GDK_FOCUS_CHANGE);
1048 CASE (GDK_CONFIGURE);
1051 CASE (GDK_PROPERTY_NOTIFY);
1052 CASE (GDK_SELECTION_CLEAR);
1053 CASE (GDK_SELECTION_REQUEST);
1054 CASE (GDK_SELECTION_NOTIFY);
1055 CASE (GDK_PROXIMITY_IN);
1056 CASE (GDK_PROXIMITY_OUT);
1057 CASE (GDK_DRAG_ENTER);
1058 CASE (GDK_DRAG_LEAVE);
1059 CASE (GDK_DRAG_MOTION);
1060 CASE (GDK_DRAG_STATUS);
1061 CASE (GDK_DROP_START);
1062 CASE (GDK_DROP_FINISHED);
1063 CASE (GDK_CLIENT_EVENT);
1064 CASE (GDK_VISIBILITY_NOTIFY);
1065 CASE (GDK_NO_EXPOSE);
1067 CASE (GDK_WINDOW_STATE);
1070 g_print ("%#lx ", (gulong) GDK_WINDOW_HWND (event->any.window));
1072 switch (event->any.type)
1075 g_print ("%dx%d@+%d+%d %d",
1076 event->expose.area.width,
1077 event->expose.area.height,
1078 event->expose.area.x,
1079 event->expose.area.y,
1080 event->expose.count);
1082 case GDK_MOTION_NOTIFY:
1083 g_print ("(%.4g,%.4g) %s",
1084 event->motion.x, event->motion.y,
1085 event->motion.is_hint ? "HINT " : "");
1086 print_event_state (event->motion.state);
1088 case GDK_BUTTON_PRESS:
1089 case GDK_2BUTTON_PRESS:
1090 case GDK_3BUTTON_PRESS:
1091 case GDK_BUTTON_RELEASE:
1092 g_print ("%d (%.4g,%.4g) ",
1093 event->button.button,
1094 event->button.x, event->button.y);
1095 print_event_state (event->button.state);
1098 case GDK_KEY_RELEASE:
1099 if (event->key.length == 0)
1100 escaped = g_strdup ("");
1102 escaped = g_strescape (event->key.string, NULL);
1103 kvname = gdk_keyval_name (event->key.keyval);
1104 g_print ("%s %d:\"%s\" ",
1105 (kvname ? kvname : "??"),
1109 print_event_state (event->key.state);
1111 case GDK_ENTER_NOTIFY:
1112 case GDK_LEAVE_NOTIFY:
1114 (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
1115 (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
1116 (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
1121 (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
1122 (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
1123 (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
1124 (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
1126 print_event_state (event->scroll.state);
1128 case GDK_WINDOW_STATE:
1129 print_window_state (event->window_state.changed_mask);
1130 print_window_state (event->window_state.new_window_state);
1139 gdk_window_is_child (GdkWindow *parent,
1142 if (parent == NULL || window == NULL)
1145 return (gdk_window_get_parent (window) == parent ||
1146 gdk_window_is_child (parent, gdk_window_get_parent (window)));
1150 synthesize_enter_or_leave_event (GdkWindow *window,
1153 GdkNotifyType detail,
1159 event = gdk_event_new ();
1160 event->crossing.type = type;
1161 event->crossing.window = window;
1162 event->crossing.send_event = FALSE;
1163 gdk_window_ref (event->crossing.window);
1164 event->crossing.subwindow = NULL;
1165 event->crossing.time = msg->time;
1166 event->crossing.x = x;
1167 event->crossing.y = y;
1168 event->crossing.x_root = msg->pt.x;
1169 event->crossing.y_root = msg->pt.y;
1170 event->crossing.mode = GDK_CROSSING_NORMAL;
1171 event->crossing.detail = detail;
1172 event->crossing.focus = TRUE; /* ??? */
1173 event->crossing.state = 0; /* ??? */
1175 gdk_event_queue_append (event);
1177 if (type == GDK_ENTER_NOTIFY
1178 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
1179 _gdk_input_enter_event (&event->crossing, window);
1181 GDK_NOTE (EVENTS, print_event (event));
1185 synthesize_leave_event (GdkWindow *window,
1187 GdkNotifyType detail)
1191 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1194 /* Leave events are at (current_x,current_y) in current_window */
1196 if (current_window != window)
1200 ClientToScreen (GDK_WINDOW_HWND (current_window), &pt);
1201 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1202 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, pt.x, pt.y);
1205 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, current_x, current_y);
1210 synthesize_enter_event (GdkWindow *window,
1212 GdkNotifyType detail)
1216 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK))
1219 /* Enter events are at LOWORD (msg->lParam), HIWORD
1220 * (msg->lParam) in msg->hwnd */
1222 pt.x = LOWORD (msg->lParam);
1223 pt.y = HIWORD (msg->lParam);
1224 if (msg->hwnd != GDK_WINDOW_HWND (window))
1226 ClientToScreen (msg->hwnd, &pt);
1227 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1229 synthesize_enter_or_leave_event (window, msg, GDK_ENTER_NOTIFY, detail, pt.x, pt.y);
1233 synthesize_enter_events (GdkWindow *from,
1236 GdkNotifyType detail)
1238 GdkWindow *prev = gdk_window_get_parent (to);
1241 synthesize_enter_events (from, prev, msg, detail);
1242 synthesize_enter_event (to, msg, detail);
1246 synthesize_leave_events (GdkWindow *from,
1249 GdkNotifyType detail)
1251 GdkWindow *next = gdk_window_get_parent (from);
1253 synthesize_leave_event (from, msg, detail);
1255 synthesize_leave_events (next, to, msg, detail);
1259 synthesize_crossing_events (GdkWindow *window,
1262 GdkWindow *intermediate, *tem, *common_ancestor;
1264 if (gdk_window_is_child (current_window, window))
1266 /* Pointer has moved to an inferior window. */
1267 synthesize_leave_event (current_window, msg, GDK_NOTIFY_INFERIOR);
1269 /* If there are intermediate windows, generate ENTER_NOTIFY
1272 intermediate = gdk_window_get_parent (window);
1273 if (intermediate != current_window)
1275 synthesize_enter_events (current_window, intermediate, msg, GDK_NOTIFY_VIRTUAL);
1278 synthesize_enter_event (window, msg, GDK_NOTIFY_ANCESTOR);
1280 else if (gdk_window_is_child (window, current_window))
1282 /* Pointer has moved to an ancestor window. */
1283 synthesize_leave_event (current_window, msg, GDK_NOTIFY_ANCESTOR);
1285 /* If there are intermediate windows, generate LEAVE_NOTIFY
1288 intermediate = gdk_window_get_parent (current_window);
1289 if (intermediate != window)
1291 synthesize_leave_events (intermediate, window, msg, GDK_NOTIFY_VIRTUAL);
1294 else if (current_window)
1296 /* Find least common ancestor of current_window and window */
1297 tem = current_window;
1299 common_ancestor = gdk_window_get_parent (tem);
1300 tem = common_ancestor;
1301 } while (common_ancestor &&
1302 !gdk_window_is_child (common_ancestor, window));
1303 if (common_ancestor)
1305 synthesize_leave_event (current_window, msg, GDK_NOTIFY_NONLINEAR);
1306 intermediate = gdk_window_get_parent (current_window);
1307 if (intermediate != common_ancestor)
1309 synthesize_leave_events (intermediate, common_ancestor,
1310 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1312 intermediate = gdk_window_get_parent (window);
1313 if (intermediate != common_ancestor)
1315 synthesize_enter_events (common_ancestor, intermediate,
1316 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1318 synthesize_enter_event (window, msg, GDK_NOTIFY_NONLINEAR);
1323 /* Dunno where we are coming from */
1324 synthesize_enter_event (window, msg, GDK_NOTIFY_UNKNOWN);
1328 gdk_window_unref (current_window);
1329 current_window = window;
1330 gdk_window_ref (current_window);
1334 translate_mouse_coords (GdkWindow *window1,
1340 pt.x = LOWORD (msg->lParam);
1341 pt.y = HIWORD (msg->lParam);
1342 ClientToScreen (GDK_WINDOW_HWND (window1), &pt);
1343 ScreenToClient (GDK_WINDOW_HWND (window2), &pt);
1344 msg->lParam = MAKELPARAM (pt.x, pt.y);
1345 GDK_NOTE (EVENTS, g_print ("...new coords are (%ld,%ld)\n", pt.x, pt.y));
1349 propagate (GdkWindow **window,
1351 GdkWindow *grab_window,
1352 gboolean grab_owner_events,
1354 gboolean (*doesnt_want_it) (gint mask,
1357 if (grab_window != NULL && !grab_owner_events)
1359 /* Event source is grabbed with owner_events FALSE */
1360 GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE, "));
1361 if ((*doesnt_want_it) (grab_mask, msg))
1363 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1368 GDK_NOTE (EVENTS, g_print ("...sending to grabber %#lx\n",
1369 (gulong) GDK_WINDOW_HWND (grab_window)));
1370 gdk_drawable_unref (*window);
1371 *window = grab_window;
1372 gdk_drawable_ref (*window);
1378 if ((*doesnt_want_it) (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (*window)->impl)->event_mask, msg))
1380 /* Owner doesn't want it, propagate to parent. */
1381 if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == gdk_parent_root)
1383 /* No parent; check if grabbed */
1384 if (grab_window != NULL)
1386 /* Event source is grabbed with owner_events TRUE */
1387 GDK_NOTE (EVENTS, g_print ("...undelivered, but grabbed\n"));
1388 if ((*doesnt_want_it) (grab_mask, msg))
1390 /* Grabber doesn't want it either */
1391 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1398 g_print ("...sending to grabber %#lx\n",
1399 (gulong) GDK_WINDOW_HWND (grab_window)));
1400 gdk_drawable_unref (*window);
1401 *window = grab_window;
1402 gdk_drawable_ref (*window);
1408 GDK_NOTE (EVENTS, g_print ("...undelivered\n"));
1414 gdk_drawable_unref (*window);
1415 *window = GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent);
1416 gdk_drawable_ref (*window);
1417 GDK_NOTE (EVENTS, g_print ("...propagating to %#lx\n",
1418 (gulong) GDK_WINDOW_HWND (*window)));
1419 /* The only branch where we actually continue the loop */
1428 doesnt_want_key (gint mask,
1431 return (((msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
1432 && !(mask & GDK_KEY_RELEASE_MASK))
1434 ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1435 && !(mask & GDK_KEY_PRESS_MASK)));
1439 doesnt_want_char (gint mask,
1442 return !(mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK));
1446 doesnt_want_button_press (gint mask,
1449 return !(mask & GDK_BUTTON_PRESS_MASK);
1453 doesnt_want_button_release (gint mask,
1456 return !(mask & GDK_BUTTON_RELEASE_MASK);
1460 doesnt_want_button_motion (gint mask,
1463 return !((mask & GDK_POINTER_MOTION_MASK)
1464 || ((msg->wParam & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))
1465 && (mask & GDK_BUTTON_MOTION_MASK))
1466 || ((msg->wParam & MK_LBUTTON)
1467 && (mask & GDK_BUTTON1_MOTION_MASK))
1468 || ((msg->wParam & MK_MBUTTON)
1469 && (mask & GDK_BUTTON2_MOTION_MASK))
1470 || ((msg->wParam & MK_RBUTTON)
1471 && (mask & GDK_BUTTON3_MOTION_MASK)));
1475 doesnt_want_scroll (gint mask,
1479 return !(mask & GDK_SCROLL_MASK);
1481 return !(mask & GDK_BUTTON_PRESS_MASK);
1486 decode_key_lparam (LPARAM lParam)
1488 static char buf[100];
1491 if (HIWORD (lParam) & KF_UP)
1492 p += sprintf (p, "KF_UP ");
1493 if (HIWORD (lParam) & KF_REPEAT)
1494 p += sprintf (p, "KF_REPEAT ");
1495 if (HIWORD (lParam) & KF_ALTDOWN)
1496 p += sprintf (p, "KF_ALTDOWN ");
1497 if (HIWORD (lParam) & KF_EXTENDED)
1498 p += sprintf (p, "KF_EXTENDED ");
1499 p += sprintf (p, "sc%d rep%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
1505 gdk_event_translate (GdkEvent *event,
1507 gboolean *ret_val_flagp,
1509 gboolean return_exposes)
1513 PAINTSTRUCT paintstruct;
1526 * window_impl == GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)
1529 GdkWindowImplWin32 *window_impl;
1530 #define ASSIGN_WINDOW(rhs) \
1532 window_impl = (window ? GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl) : NULL))
1534 GdkWindow *orig_window, *new_window;
1535 GdkColormap *colormap;
1536 GdkColormapPrivateWin32 *colormap_private;
1538 GdkPixmapImplWin32 *pixmap_impl;
1544 gboolean return_val;
1549 *ret_val_flagp = FALSE;
1551 ASSIGN_WINDOW (gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd));
1552 orig_window = window;
1554 event->any.window = window;
1556 /* InSendMessage() does not really mean the same as X11's send_event flag,
1557 * but it is close enough, says jpe@archaeopteryx.com.
1559 event->any.send_event = InSendMessage ();
1563 /* Handle WM_QUIT here ? */
1564 if (msg->message == WM_QUIT)
1566 GDK_NOTE (EVENTS, g_print ("WM_QUIT: %d\n", msg->wParam));
1569 else if (msg->message == WM_MOVE
1570 || msg->message == WM_SIZE)
1572 /* It's quite normal to get these messages before we have
1573 * had time to register the window in our lookup table, or
1574 * when the window is being destroyed and we already have
1575 * removed it. Repost the same message to our queue so that
1576 * we will get it later when we are prepared.
1578 GDK_NOTE(MISC, g_print("gdk_event_translate: %#lx %s posted.\n",
1580 msg->message == WM_MOVE ?
1581 "WM_MOVE" : "WM_SIZE"));
1583 PostMessage (msg->hwnd, msg->message,
1584 msg->wParam, msg->lParam);
1586 #ifndef WITHOUT_WM_CREATE
1587 else if (WM_CREATE == msg->message)
1589 window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
1590 GDK_WINDOW_HWND (window) = msg->hwnd;
1591 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: created %#x\n",
1592 (guint) msg->hwnd));
1594 /* This should handle allmost all the other window==NULL cases.
1595 * This code is executed while gdk_window_new is in it's
1596 * CreateWindowEx call.
1597 * Don't insert xid there a second time, if it's done here.
1599 gdk_drawable_ref (window);
1600 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND(window), window);
1605 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: %s for %#x (NULL)\n",
1606 gdk_win32_message_name(msg->message),
1607 (guint) msg->hwnd));
1613 gdk_drawable_ref (window);
1615 if (!GDK_WINDOW_DESTROYED (window))
1617 /* Check for filters for this window */
1618 GdkFilterReturn result;
1620 result = gdk_event_apply_filters
1621 (msg, event, GDK_WINDOW_OBJECT (window)->filters);
1623 if (result != GDK_FILTER_CONTINUE)
1625 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1626 *ret_val_flagp = TRUE;
1627 *ret_valp = return_val;
1632 if (msg->message == gdk_selection_notify_msg)
1634 GDK_NOTE (EVENTS, g_print ("gdk_selection_notify_msg: %#lx\n",
1635 (gulong) msg->hwnd));
1637 event->selection.type = GDK_SELECTION_NOTIFY;
1638 event->selection.window = window;
1639 event->selection.selection = msg->wParam;
1640 event->selection.target = msg->lParam;
1641 event->selection.property = gdk_selection_property;
1642 event->selection.time = msg->time;
1644 return_val = !GDK_WINDOW_DESTROYED (window);
1648 else if (msg->message == gdk_selection_request_msg)
1650 GDK_NOTE (EVENTS, g_print ("gdk_selection_request_msg: %#lx\n",
1651 (gulong) msg->hwnd));
1653 event->selection.type = GDK_SELECTION_REQUEST;
1654 event->selection.window = window;
1655 event->selection.selection = gdk_clipboard_atom;
1656 event->selection.target = GDK_TARGET_STRING;
1657 event->selection.property = gdk_selection_property;
1658 event->selection.requestor = (guint32) msg->hwnd;
1659 event->selection.time = msg->time;
1661 return_val = !GDK_WINDOW_DESTROYED (window);
1665 else if (msg->message == gdk_selection_clear_msg)
1667 GDK_NOTE (EVENTS, g_print ("gdk_selection_clear_msg: %#lx\n",
1668 (gulong) msg->hwnd));
1670 event->selection.type = GDK_SELECTION_CLEAR;
1671 event->selection.window = window;
1672 event->selection.selection = msg->wParam;
1673 event->selection.time = msg->time;
1675 return_val = !GDK_WINDOW_DESTROYED (window);
1679 else if (msg->message == msh_mousewheel_msg)
1681 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %#lx %d\n",
1682 (gulong) msg->hwnd, msg->wParam));
1684 event->scroll.type = GDK_SCROLL;
1686 /* MSG_MOUSEWHEEL is delivered to the foreground window. Work
1687 * around that. Also, the position is in screen coordinates, not
1688 * client coordinates as with the button messages.
1690 pt.x = LOWORD (msg->lParam);
1691 pt.y = HIWORD (msg->lParam);
1692 if ((hwnd = WindowFromPoint (pt)) == NULL)
1696 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
1699 if (new_window != window)
1701 gdk_drawable_unref (window);
1702 ASSIGN_WINDOW (new_window);
1703 gdk_drawable_ref (window);
1706 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
1707 && gdk_input_ignore_core)
1709 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
1713 if (!propagate (&window, msg,
1714 p_grab_window, p_grab_owner_events, p_grab_mask,
1715 doesnt_want_scroll))
1718 ASSIGN_WINDOW (window);
1720 ScreenToClient (msg->hwnd, &pt);
1721 event->button.window = window;
1722 event->scroll.direction = ((int) msg->wParam > 0) ?
1723 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
1724 event->scroll.window = window;
1725 event->scroll.time = msg->time;
1726 event->scroll.x = (gint16) pt.x;
1727 event->scroll.y = (gint16) pt.y;
1728 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
1729 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
1730 event->scroll.state = 0; /* No state information with MSH_MOUSEWHEEL */
1731 event->scroll.device = gdk_core_pointer;
1732 return_val = !GDK_WINDOW_DESTROYED (window);
1739 GdkFilterReturn result = GDK_FILTER_CONTINUE;
1741 tmp_list = client_filters;
1744 GdkClientFilter *filter = tmp_list->data;
1745 if (filter->type == msg->message)
1747 GDK_NOTE (EVENTS, g_print ("client filter matched\n"));
1748 event->any.window = window;
1749 result = (*filter->function) (msg, event, filter->data);
1752 case GDK_FILTER_REMOVE:
1753 *ret_val_flagp = TRUE;
1758 case GDK_FILTER_TRANSLATE:
1762 case GDK_FILTER_CONTINUE:
1763 *ret_val_flagp = TRUE;
1766 event->client.type = GDK_CLIENT_EVENT;
1767 event->client.window = window;
1768 event->client.message_type = msg->message;
1769 event->client.data_format = 0;
1770 event->client.data.l[0] = msg->wParam;
1771 event->client.data.l[1] = msg->lParam;
1776 tmp_list = tmp_list->next;
1780 switch (msg->message)
1782 case WM_INPUTLANGCHANGE:
1784 g_print ("WM_INPUTLANGCHANGE: %#lx charset %lu locale %lx\n",
1785 (gulong) msg->hwnd, (gulong) msg->wParam, msg->lParam));
1786 window_impl->input_locale = (HKL) msg->lParam;
1787 TranslateCharsetInfo ((DWORD FAR *) msg->wParam,
1788 &window_impl->charset_info,
1795 g_print ("WM_SYSKEY%s: %#lx %s %#x %s\n",
1796 (msg->message == WM_SYSKEYUP ? "UP" : "DOWN"),
1798 (GetKeyNameText (msg->lParam, buf,
1802 decode_key_lparam (msg->lParam)));
1804 /* Let the system handle Alt-Tab and Alt-Enter */
1805 if (msg->wParam == VK_TAB
1806 || msg->wParam == VK_RETURN
1807 || msg->wParam == VK_F4)
1809 /* If posted without us having keyboard focus, ignore */
1810 if (!(msg->lParam & 0x20000000))
1813 /* don't generate events for just the Alt key */
1814 if (msg->wParam == VK_MENU)
1817 /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
1823 g_print ("WM_KEY%s: %#lx %s %#x %s\n",
1824 (msg->message == WM_KEYUP ? "UP" : "DOWN"),
1826 (GetKeyNameText (msg->lParam, buf,
1830 decode_key_lparam (msg->lParam)));
1832 ignore_wm_char = TRUE;
1836 event->key.window = window;
1837 event->key.hardware_keycode = msg->wParam;
1839 switch (msg->wParam)
1842 event->key.keyval = GDK_Pointer_Button1; break;
1844 event->key.keyval = GDK_Pointer_Button3; break;
1846 event->key.keyval = GDK_Pointer_Button2; break;
1848 event->key.keyval = GDK_Cancel; break;
1850 event->key.keyval = GDK_BackSpace; break;
1852 event->key.keyval = (GetKeyState(VK_SHIFT) < 0 ?
1853 GDK_ISO_Left_Tab : GDK_Tab);
1856 event->key.keyval = GDK_Clear; break;
1858 event->key.keyval = GDK_Return; break;
1860 /* Don't let Shift auto-repeat */
1861 if (msg->message == WM_KEYDOWN
1862 && (HIWORD (msg->lParam) & KF_REPEAT))
1863 ignore_wm_char = FALSE;
1865 event->key.keyval = GDK_Shift_L;
1868 /* And not Control either */
1869 if (msg->message == WM_KEYDOWN
1870 && (HIWORD (msg->lParam) & KF_REPEAT))
1871 ignore_wm_char = FALSE;
1872 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1873 event->key.keyval = GDK_Control_R;
1875 event->key.keyval = GDK_Control_L;
1879 if (msg->message == WM_KEYDOWN
1880 && (HIWORD (msg->lParam) & KF_REPEAT))
1881 ignore_wm_char = FALSE;
1882 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1884 /* AltGr key comes in as Control+Right Alt */
1885 if (GetKeyState (VK_CONTROL) < 0)
1887 ignore_wm_char = FALSE;
1888 is_altgr_key = TRUE;
1890 event->key.keyval = GDK_Alt_R;
1894 event->key.keyval = GDK_Alt_L;
1895 /* This needed in case she types Alt+nnn (on the numpad) */
1896 ignore_wm_char = FALSE;
1900 event->key.keyval = GDK_Pause; break;
1902 event->key.keyval = GDK_Caps_Lock; break;
1904 event->key.keyval = GDK_Escape; break;
1906 event->key.keyval = GDK_Prior; break;
1908 event->key.keyval = GDK_Next; break;
1910 event->key.keyval = GDK_End; break;
1912 event->key.keyval = GDK_Home; break;
1914 event->key.keyval = GDK_Left; break;
1916 event->key.keyval = GDK_Up; break;
1918 event->key.keyval = GDK_Right; break;
1920 event->key.keyval = GDK_Down; break;
1922 event->key.keyval = GDK_Select; break;
1924 event->key.keyval = GDK_Print; break;
1926 event->key.keyval = GDK_Execute; break;
1928 event->key.keyval = GDK_Insert; break;
1930 event->key.keyval = GDK_Delete; break;
1932 event->key.keyval = GDK_Help; break;
1943 /* Apparently applications work better if we just pass numpad digits
1944 * on as real digits? So wait for the WM_CHAR instead.
1946 ignore_wm_char = FALSE;
1949 event->key.keyval = GDK_KP_Multiply; break;
1951 /* Pass it on as an ASCII plus in WM_CHAR. */
1952 ignore_wm_char = FALSE;
1955 event->key.keyval = GDK_KP_Separator; break;
1957 /* Pass it on as an ASCII minus in WM_CHAR. */
1958 ignore_wm_char = FALSE;
1961 /* The keypad decimal key should also be passed on as the decimal
1962 * sign ('.' or ',' depending on the Windows locale settings,
1963 * apparently). So wait for the WM_CHAR here, also.
1965 ignore_wm_char = FALSE;
1968 event->key.keyval = GDK_KP_Divide; break;
1970 event->key.keyval = GDK_F1; break;
1972 event->key.keyval = GDK_F2; break;
1974 event->key.keyval = GDK_F3; break;
1976 event->key.keyval = GDK_F4; break;
1978 event->key.keyval = GDK_F5; break;
1980 event->key.keyval = GDK_F6; break;
1982 event->key.keyval = GDK_F7; break;
1984 event->key.keyval = GDK_F8; break;
1986 event->key.keyval = GDK_F9; break;
1988 event->key.keyval = GDK_F10; break;
1990 event->key.keyval = GDK_F11; break;
1992 event->key.keyval = GDK_F12; break;
1994 event->key.keyval = GDK_F13; break;
1996 event->key.keyval = GDK_F14; break;
1998 event->key.keyval = GDK_F15; break;
2000 event->key.keyval = GDK_F16; break;
2011 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2012 || GetKeyState (VK_MENU) < 0))
2013 /* Control- or Alt-digits won't come in as a WM_CHAR,
2014 * but beware of AltGr-digits, which are used for instance
2015 * on Finnish keyboards.
2017 event->key.keyval = GDK_0 + (msg->wParam - '0');
2019 ignore_wm_char = FALSE;
2021 case VK_OEM_PLUS: /* On my Win98, the '+' key comes in
2022 * as VK_OEM_PLUS, etc.
2031 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2032 || GetKeyState (VK_MENU) < 0))
2033 /* Control- or Alt-plus won't come in as WM_CHAR,
2034 * but beware of AltGr-plus which is backslash on
2037 /* All these VK_OEM keycodes happen to be the corresponding ASCII
2040 event->key.keyval = msg->wParam - 0x90;
2042 ignore_wm_char = FALSE;
2045 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2046 || GetKeyState (VK_MENU) < 0))
2047 /* ;: on US keyboard */
2048 event->key.keyval = ';';
2050 ignore_wm_char = FALSE;
2053 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2054 || GetKeyState (VK_MENU) < 0))
2055 /* `~ on US keyboard */
2056 event->key.keyval = '`';
2058 ignore_wm_char = FALSE;
2061 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2062 || GetKeyState (VK_MENU) < 0))
2063 /* '" on US keyboard */
2064 event->key.keyval = '\'';
2066 ignore_wm_char = FALSE;
2069 if (msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSKEYUP)
2070 event->key.keyval = msg->wParam;
2072 ignore_wm_char = FALSE;
2076 if (!ignore_wm_char)
2079 if (!propagate (&window, msg,
2080 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2083 ASSIGN_WINDOW (window);
2085 is_altgr_key = FALSE;
2086 event->key.type = ((msg->message == WM_KEYDOWN
2087 || msg->message == WM_SYSKEYDOWN) ?
2088 GDK_KEY_PRESS : GDK_KEY_RELEASE);
2089 event->key.time = msg->time;
2090 event->key.state = 0;
2091 if (GetKeyState (VK_SHIFT) < 0)
2092 event->key.state |= GDK_SHIFT_MASK;
2093 if (GetKeyState (VK_CAPITAL) & 0x1)
2094 event->key.state |= GDK_LOCK_MASK;
2095 if (GetKeyState (VK_CONTROL) < 0)
2096 event->key.state |= GDK_CONTROL_MASK;
2097 if (msg->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
2098 event->key.state |= GDK_MOD1_MASK;
2099 event->key.string = NULL;
2100 event->key.length = 0;
2101 return_val = !GDK_WINDOW_DESTROYED (window);
2104 case WM_IME_COMPOSITION:
2105 if (!use_ime_composition)
2108 GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %#lx %#lx\n",
2109 (gulong) msg->hwnd, msg->lParam));
2110 if (msg->lParam & GCS_RESULTSTR)
2116 g_print ("WM_IME_CHAR: %#lx bytes: %#.04x\n",
2117 (gulong) msg->hwnd, msg->wParam));
2123 g_print ("WM_%sCHAR: %#lx %#x %s %s\n",
2124 (msg->message == WM_CHAR ? "" : "SYS"),
2125 (gulong) msg->hwnd, msg->wParam,
2126 decode_key_lparam (msg->lParam),
2127 (ignore_wm_char ? "ignored" : "")));
2131 ignore_wm_char = FALSE;
2136 if (!propagate (&window, msg,
2137 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2140 ASSIGN_WINDOW (window);
2142 event->key.window = window;
2143 return_val = !GDK_WINDOW_DESTROYED (window);
2145 if (return_val && (event->key.window == k_grab_window
2146 || (window_impl->event_mask & GDK_KEY_RELEASE_MASK)))
2148 if (window == k_grab_window
2149 || (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2151 /* Append a GDK_KEY_PRESS event to the pushback list
2152 * (from which it will be fetched before the release
2155 GdkEvent *event2 = gdk_event_new ();
2156 build_keypress_event (window_impl, event2, msg);
2157 event2->key.window = window;
2158 gdk_drawable_ref (window);
2159 gdk_event_queue_append (event2);
2160 GDK_NOTE (EVENTS, print_event (event2));
2162 /* Return the key release event. */
2163 build_keyrelease_event (window_impl, event, msg);
2166 && (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2168 /* Return just the key press event. */
2169 build_keypress_event (window_impl, event, msg);
2174 #if 0 /* Don't reset is_AltGr_key here. Othewise we can't type several
2175 * AltGr-accessed chars while keeping the AltGr pressed down
2178 is_AltGr_key = FALSE;
2182 case WM_LBUTTONDOWN:
2185 case WM_MBUTTONDOWN:
2188 case WM_RBUTTONDOWN:
2193 g_print ("WM_%cBUTTONDOWN: %#lx (%d,%d)\n",
2196 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2198 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2199 && gdk_input_ignore_core)
2201 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2205 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2207 if (window != current_window)
2208 synthesize_crossing_events (window, msg);
2210 event->button.type = GDK_BUTTON_PRESS;
2211 if (!propagate (&window, msg,
2212 p_grab_window, p_grab_owner_events, p_grab_mask,
2213 doesnt_want_button_press))
2215 ASSIGN_WINDOW (window);
2217 event->button.window = window;
2219 /* Emulate X11's automatic active grab */
2222 /* No explicit active grab, let's start one automatically */
2223 gint owner_events = window_impl->event_mask
2224 & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
2226 GDK_NOTE (EVENTS, g_print ("...automatic grab started\n"));
2227 gdk_pointer_grab (window,
2229 window_impl->event_mask,
2231 p_grab_automatic = TRUE;
2234 event->button.time = msg->time;
2235 if (window != orig_window)
2236 translate_mouse_coords (orig_window, window, msg);
2237 event->button.x = current_x = (gint16) LOWORD (msg->lParam);
2238 event->button.y = current_y = (gint16) HIWORD (msg->lParam);
2239 event->button.x_root = msg->pt.x;
2240 event->button.y_root = msg->pt.y;
2241 event->button.axes = NULL;
2242 event->button.state = build_pointer_event_state (msg);
2243 event->button.button = button;
2244 event->button.device = gdk_core_pointer;
2246 gdk_event_button_generate (event);
2248 return_val = !GDK_WINDOW_DESTROYED (window);
2262 g_print ("WM_%cBUTTONUP: %#lx (%d,%d)\n",
2265 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2267 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2269 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2270 && gdk_input_ignore_core)
2272 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2276 if (window != current_window)
2277 synthesize_crossing_events (window, msg);
2279 event->button.type = GDK_BUTTON_RELEASE;
2280 if (!propagate (&window, msg,
2281 p_grab_window, p_grab_owner_events, p_grab_mask,
2282 doesnt_want_button_release))
2287 ASSIGN_WINDOW (window);
2289 event->button.window = window;
2290 event->button.time = msg->time;
2291 if (window != orig_window)
2292 translate_mouse_coords (orig_window, window, msg);
2293 event->button.x = (gint16) LOWORD (msg->lParam);
2294 event->button.y = (gint16) HIWORD (msg->lParam);
2295 event->button.x_root = msg->pt.x;
2296 event->button.y_root = msg->pt.y;
2297 event->button.axes = NULL;
2298 event->button.state = build_pointer_event_state (msg);
2299 event->button.button = button;
2300 event->button.device = gdk_core_pointer;
2302 return_val = !GDK_WINDOW_DESTROYED (window);
2305 if (p_grab_window != NULL
2307 && (msg->wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) == 0)
2308 gdk_pointer_ungrab (0);
2313 g_print ("WM_MOUSEMOVE: %#lx %#x (%d,%d)\n",
2314 (gulong) msg->hwnd, msg->wParam,
2315 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2317 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2319 /* If we haven't moved, don't create any event.
2320 * Windows sends WM_MOUSEMOVE messages after button presses
2321 * even if the mouse doesn't move. This disturbs gtk.
2323 if (window == current_window
2324 && LOWORD (msg->lParam) == current_x
2325 && HIWORD (msg->lParam) == current_y)
2328 /* HB: only process mouse move messages if we own the active window. */
2329 GetWindowThreadProcessId(GetActiveWindow(), &pidActWin);
2330 GetWindowThreadProcessId(msg->hwnd, &pidThis);
2331 if (pidActWin != pidThis)
2334 if (window != current_window)
2335 synthesize_crossing_events (window, msg);
2337 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2338 && gdk_input_ignore_core)
2340 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2344 event->motion.type = GDK_MOTION_NOTIFY;
2345 if (!propagate (&window, msg,
2346 p_grab_window, p_grab_owner_events, p_grab_mask,
2347 doesnt_want_button_motion))
2349 ASSIGN_WINDOW (window);
2351 event->motion.window = window;
2352 event->motion.time = msg->time;
2353 if (window != orig_window)
2354 translate_mouse_coords (orig_window, window, msg);
2355 event->motion.x = current_x = (gint16) LOWORD (msg->lParam);
2356 event->motion.y = current_y = (gint16) HIWORD (msg->lParam);
2357 event->motion.x_root = current_x_root = msg->pt.x;
2358 event->motion.y_root = current_y_root = msg->pt.y;
2359 event->motion.axes = NULL;
2360 event->motion.state = build_pointer_event_state (msg);
2361 event->motion.is_hint = FALSE;
2362 event->motion.device = gdk_core_pointer;
2364 return_val = !GDK_WINDOW_DESTROYED (window);
2367 case WM_NCMOUSEMOVE:
2369 g_print ("WM_NCMOUSEMOVE: %#lx x,y: %d %d\n",
2371 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2372 if (track_mouse_event == NULL
2373 && current_window != NULL
2374 && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2376 GDK_NOTE (EVENTS, g_print ("...synthesizing LEAVE_NOTIFY event\n"));
2378 event->crossing.type = GDK_LEAVE_NOTIFY;
2379 event->crossing.window = current_window;
2380 event->crossing.subwindow = NULL;
2381 event->crossing.time = msg->time;
2382 event->crossing.x = current_x;
2383 event->crossing.y = current_y;
2384 event->crossing.x_root = current_x_root;
2385 event->crossing.y_root = current_y_root;
2386 event->crossing.mode = GDK_CROSSING_NORMAL;
2387 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2389 event->crossing.focus = TRUE; /* ??? */
2390 event->crossing.state = 0; /* ??? */
2396 gdk_drawable_unref (current_window);
2397 current_window = NULL;
2403 GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %#lx %d\n",
2404 (gulong) msg->hwnd, HIWORD (msg->wParam)));
2406 event->scroll.type = GDK_SCROLL;
2408 /* WM_MOUSEWHEEL is delivered to the focus window Work around
2409 * that. Also, the position is in screen coordinates, not client
2410 * coordinates as with the button messages. I love the
2411 * consistency of Windows.
2413 pt.x = LOWORD (msg->lParam);
2414 pt.y = HIWORD (msg->lParam);
2415 if ((hwnd = WindowFromPoint (pt)) == NULL)
2419 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2422 if (new_window != window)
2424 gdk_drawable_unref (window);
2425 ASSIGN_WINDOW (new_window);
2426 gdk_drawable_ref (window);
2429 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2430 && gdk_input_ignore_core)
2432 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2436 if (!propagate (&window, msg,
2437 p_grab_window, p_grab_owner_events, p_grab_mask,
2438 doesnt_want_scroll))
2441 ASSIGN_WINDOW (window);
2443 ScreenToClient (msg->hwnd, &pt);
2444 event->button.window = window;
2445 event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2446 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2447 event->scroll.window = window;
2448 event->scroll.time = msg->time;
2449 event->scroll.x = (gint16) pt.x;
2450 event->scroll.y = (gint16) pt.y;
2451 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
2452 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
2453 event->scroll.state = build_pointer_event_state (msg);
2454 event->scroll.device = gdk_core_pointer;
2455 return_val = !GDK_WINDOW_DESTROYED (window);
2459 #ifdef USE_TRACKMOUSEEVENT
2461 GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %#lx\n", (gulong) msg->hwnd));
2463 if (!(window_impl->event_mask & GDK_LEAVE_NOTIFY_MASK))
2466 event->crossing.type = GDK_LEAVE_NOTIFY;
2467 event->crossing.window = window;
2468 event->crossing.subwindow = NULL;
2469 event->crossing.time = msg->time;
2470 event->crossing.x = current_x;
2471 event->crossing.y = current_y;
2472 event->crossing.x_root = current_xroot;
2473 event->crossing.y_root = current_yroot;
2474 event->crossing.mode = GDK_CROSSING_NORMAL;
2476 && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
2477 event->crossing.detail = GDK_NOTIFY_INFERIOR;
2478 else if (current_window
2479 && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
2480 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
2482 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2484 event->crossing.focus = TRUE; /* ??? */
2485 event->crossing.state = 0; /* ??? */
2489 gdk_drawable_unref (current_window);
2490 current_window = NULL;
2493 return_val = !GDK_WINDOW_DESTROYED (window);
2499 GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %#lx\n",
2500 (msg->message == WM_SETFOCUS ?
2502 (gulong) msg->hwnd));
2504 if (!(window_impl->event_mask & GDK_FOCUS_CHANGE_MASK))
2507 event->focus_change.type = GDK_FOCUS_CHANGE;
2508 event->focus_change.window = window;
2509 event->focus_change.in = (msg->message == WM_SETFOCUS);
2510 return_val = !GDK_WINDOW_DESTROYED (window);
2514 GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#lx dc %#x\n",
2515 (gulong) msg->hwnd, msg->wParam));
2517 if (GDK_WINDOW_DESTROYED (window))
2520 if (GDK_WINDOW_OBJECT (window)->input_only)
2523 if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg)
2525 /* improves scolling effect, e.g. main buttons of testgtk */
2526 *ret_val_flagp = TRUE;
2531 colormap = GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap;
2533 colormap_private = GDK_COLORMAP_PRIVATE_DATA (colormap);
2534 hdc = (HDC) msg->wParam;
2535 if (colormap && colormap_private->xcolormap->rc_palette)
2539 if (SelectPalette (hdc, colormap_private->xcolormap->palette,
2541 WIN32_GDI_FAILED ("SelectPalette");
2542 if ((k = RealizePalette (hdc)) == GDI_ERROR)
2543 WIN32_GDI_FAILED ("RealizePalette");
2545 g_print ("WM_ERASEBKGND: selected %#x, realized %d colors\n",
2546 colormap_private->xcolormap->palette, k);
2549 *ret_val_flagp = TRUE;
2552 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2554 /* If this window should have the same background as the
2555 * parent, fetch the parent. (And if the same goes for
2556 * the parent, fetch the grandparent, etc.)
2558 while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2560 gdk_drawable_unref (window);
2561 ASSIGN_WINDOW (GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent));
2562 gdk_drawable_ref (window);
2566 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
2568 bg = gdk_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
2569 GDK_WINDOW_OBJECT (window)->bg_color.pixel);
2571 GetClipBox (hdc, &rect);
2573 g_print ("...%ldx%ld@+%ld+%ld BG_PIXEL %.06lx\n",
2574 rect.right - rect.left,
2575 rect.bottom - rect.top,
2576 rect.left, rect.top,
2578 hbr = CreateSolidBrush (bg);
2580 g_print ("...CreateSolidBrush (%.08x) = %.08x\n", bg, hbr);
2582 if (!FillRect (hdc, &rect, hbr))
2583 WIN32_GDI_FAILED ("FillRect");
2586 else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
2587 GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
2589 pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
2590 pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl);
2591 GetClipBox (hdc, &rect);
2593 if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
2595 GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
2596 hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap));
2597 if (!FillRect (hdc, &rect, hbr))
2598 WIN32_GDI_FAILED ("FillRect");
2604 g_print ("...blitting pixmap %#lx (%dx%d) "
2605 "all over the place,\n"
2606 "...clip box = %ldx%ld@+%ld+%ld\n",
2607 (gulong) GDK_PIXMAP_HBITMAP (pixmap),
2608 pixmap_impl->width, pixmap_impl->height,
2609 rect.right - rect.left, rect.bottom - rect.top,
2610 rect.left, rect.top));
2612 if (!(bgdc = CreateCompatibleDC (hdc)))
2614 WIN32_GDI_FAILED ("CreateCompatibleDC");
2617 if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
2619 WIN32_GDI_FAILED ("SelectObject");
2624 while (i < rect.right)
2627 while (j < rect.bottom)
2629 if (i + pixmap_impl->width >= rect.left
2630 && j + pixmap_impl->height >= rect.top)
2632 if (!BitBlt (hdc, i, j,
2633 pixmap_impl->width, pixmap_impl->height,
2634 bgdc, 0, 0, SRCCOPY))
2636 WIN32_GDI_FAILED ("BitBlt");
2640 j += pixmap_impl->height;
2642 i += pixmap_impl->width;
2645 SelectObject (bgdc, oldbitmap);
2651 GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
2652 hbr = GetStockObject (BLACK_BRUSH);
2653 GetClipBox (hdc, &rect);
2654 if (!FillRect (hdc, &rect, hbr))
2655 WIN32_GDI_FAILED ("FillRect");
2660 if (!GetUpdateRect(msg->hwnd, NULL, FALSE))
2662 GDK_NOTE (EVENTS, g_print ("WM_PAINT: %#lx no update rect\n",
2663 (gulong) msg->hwnd));
2667 /* HB: don't generate GDK_EXPOSE events for InputOnly
2668 * windows -> backing store now works!
2670 if (GDK_WINDOW_OBJECT (window)->input_only)
2673 hdc = BeginPaint (msg->hwnd, &paintstruct);
2676 g_print ("WM_PAINT: %#lx %ldx%ld@+%ld+%ld %s dc %#lx\n",
2678 paintstruct.rcPaint.right - paintstruct.rcPaint.left,
2679 paintstruct.rcPaint.bottom - paintstruct.rcPaint.top,
2680 paintstruct.rcPaint.left, paintstruct.rcPaint.top,
2681 (paintstruct.fErase ? "erase" : ""),
2684 EndPaint (msg->hwnd, &paintstruct);
2686 if (!(window_impl->event_mask & GDK_EXPOSURE_MASK))
2689 if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left)
2690 || (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
2695 event->expose.type = GDK_EXPOSE;
2696 event->expose.window = window;
2697 event->expose.area.x = paintstruct.rcPaint.left;
2698 event->expose.area.y = paintstruct.rcPaint.top;
2699 event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2700 event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2701 event->expose.region = gdk_region_rectangle (&(event->expose.area));
2702 event->expose.count = 0;
2704 return_val = !GDK_WINDOW_DESTROYED (window);
2707 GList *list = gdk_queued_events;
2708 while (list != NULL )
2710 if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
2711 (((GdkEvent *)list->data)->any.window == window) &&
2712 !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
2713 ((GdkEvent *)list->data)->expose.count++;
2721 GdkRectangle expose_rect;
2723 expose_rect.x = paintstruct.rcPaint.left;
2724 expose_rect.y = paintstruct.rcPaint.top;
2725 expose_rect.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2726 expose_rect.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2728 _gdk_window_process_expose (window, GetMessageTime (), &expose_rect);
2735 GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %#lx %#x %#x\n",
2737 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2739 if (LOWORD (msg->lParam) != HTCLIENT)
2742 if (p_grab_window != NULL && p_grab_cursor != NULL)
2743 hcursor = p_grab_cursor;
2744 else if (!GDK_WINDOW_DESTROYED (window))
2745 hcursor = window_impl->hcursor;
2749 if (hcursor != NULL)
2751 GDK_NOTE (EVENTS, g_print ("...SetCursor(%#lx)\n", (gulong) hcursor));
2752 SetCursor (hcursor);
2753 *ret_val_flagp = TRUE;
2759 GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %#lx %d\n",
2763 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2766 event->any.type = (msg->wParam ? GDK_MAP : GDK_UNMAP);
2767 event->any.window = window;
2769 if (event->any.type == GDK_UNMAP
2770 && p_grab_window == window)
2771 gdk_pointer_ungrab (msg->time);
2773 if (event->any.type == GDK_UNMAP
2774 && k_grab_window == window)
2775 gdk_keyboard_ungrab (msg->time);
2777 return_val = !GDK_WINDOW_DESTROYED (window);
2782 g_print ("WM_SIZE: %#lx %s %dx%d\n",
2784 (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
2785 (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
2786 (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
2787 (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
2788 (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
2789 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2791 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2794 if (msg->wParam == SIZE_MINIMIZED)
2796 event->any.type = GDK_UNMAP;
2797 event->any.window = window;
2799 if (p_grab_window == window)
2800 gdk_pointer_ungrab (msg->time);
2802 if (k_grab_window == window)
2803 gdk_keyboard_ungrab (msg->time);
2805 return_val = !GDK_WINDOW_DESTROYED (window);
2807 else if ((msg->wParam == SIZE_RESTORED
2808 || msg->wParam == SIZE_MAXIMIZED)
2810 && GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2814 if (LOWORD (msg->lParam) == 0)
2817 event->configure.type = GDK_CONFIGURE;
2818 event->configure.window = window;
2821 ClientToScreen (msg->hwnd, &pt);
2822 event->configure.x = pt.x;
2823 event->configure.y = pt.y;
2824 event->configure.width = LOWORD (msg->lParam);
2825 event->configure.height = HIWORD (msg->lParam);
2826 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2827 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2828 window_impl->width = event->configure.width;
2829 window_impl->height = event->configure.height;
2831 if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
2832 GDK_WINDOW_OBJECT (window)->resize_count -= 1;
2834 return_val = !GDK_WINDOW_DESTROYED (window);
2836 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
2837 _gdk_input_configure_event (&event->configure, window);
2841 case WM_GETMINMAXINFO:
2842 GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %#lx\n", (gulong) msg->hwnd));
2844 mmi = (MINMAXINFO*) msg->lParam;
2845 if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
2847 mmi->ptMinTrackSize.x = window_impl->hint_min_width;
2848 mmi->ptMinTrackSize.y = window_impl->hint_min_height;
2850 if (window_impl->hint_flags & GDK_HINT_MAX_SIZE)
2852 mmi->ptMaxTrackSize.x = window_impl->hint_max_width;
2853 mmi->ptMaxTrackSize.y = window_impl->hint_max_height;
2855 mmi->ptMaxSize.x = window_impl->hint_max_width;
2856 mmi->ptMaxSize.y = window_impl->hint_max_height;
2861 GDK_NOTE (EVENTS, g_print ("WM_MOVE: %#lx (%d,%d)\n",
2863 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2865 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2868 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2869 && !IsIconic(msg->hwnd)
2870 && IsWindowVisible(msg->hwnd))
2872 event->configure.type = GDK_CONFIGURE;
2873 event->configure.window = window;
2874 event->configure.x = LOWORD (msg->lParam);
2875 event->configure.y = HIWORD (msg->lParam);
2876 GetClientRect (msg->hwnd, &rect);
2877 event->configure.width = rect.right;
2878 event->configure.height = rect.bottom;
2879 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2880 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2881 window_impl->width = event->configure.width;
2882 window_impl->height = event->configure.height;
2884 return_val = !GDK_WINDOW_DESTROYED (window);
2889 GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %#lx\n", (gulong) msg->hwnd));
2891 event->any.type = GDK_DELETE;
2892 event->any.window = window;
2894 return_val = !GDK_WINDOW_DESTROYED (window);
2898 /* No, don't use delayed rendering after all. It works only if the
2899 * delayed SetClipboardData is called from the WindowProc, it
2900 * seems. (The #else part below is test code for that. It succeeds
2901 * in setting the clipboard data. But if I call SetClipboardData
2902 * in gdk_property_change (as a consequence of the
2903 * GDK_SELECTION_REQUEST event), it fails. I deduce that this is
2904 * because delayed rendering requires that SetClipboardData is
2905 * called in the window procedure.)
2907 case WM_RENDERFORMAT:
2908 case WM_RENDERALLFORMATS:
2910 GDK_NOTE (EVENTS, flag = TRUE);
2912 g_print ("WM_%s: %#lx %#x (%s)\n",
2913 (msg->message == WM_RENDERFORMAT ? "RENDERFORMAT" :
2914 "RENDERALLFORMATS"),
2917 (msg->wParam == CF_TEXT ? "CF_TEXT" :
2918 (msg->wParam == CF_DIB ? "CF_DIB" :
2919 (msg->wParam == CF_UNICODETEXT ? "CF_UNICODETEXT" :
2920 (GetClipboardFormatName (msg->wParam, buf, sizeof (buf)), buf)))));
2923 event->selection.type = GDK_SELECTION_REQUEST;
2924 event->selection.window = window;
2925 event->selection.selection = gdk_clipboard_atom;
2926 if (msg->wParam == CF_TEXT)
2927 event->selection.target = GDK_TARGET_STRING;
2930 GetClipboardFormatName (msg->wParam, buf, sizeof (buf));
2931 event->selection.target = gdk_atom_intern (buf, FALSE);
2933 event->selection.property = gdk_selection_property;
2934 event->selection.requestor = (guint32) msg->hwnd;
2935 event->selection.time = msg->time;
2936 return_val = !GDK_WINDOW_DESTROYED (window);
2938 /* Test code, to see if SetClipboardData works when called from
2939 * the window procedure.
2942 HGLOBAL hdata = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, 10);
2943 char *ptr = GlobalLock (hdata);
2944 strcpy (ptr, "Huhhaa");
2945 GlobalUnlock (hdata);
2946 if (!SetClipboardData (CF_TEXT, hdata))
2947 WIN32_API_FAILED ("SetClipboardData");
2950 *ret_val_flagp = TRUE;
2954 #endif /* No delayed rendering */
2957 GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %#lx\n", (gulong) msg->hwnd));
2959 event->any.type = GDK_DESTROY;
2960 event->any.window = window;
2961 if (window != NULL && window == current_window)
2963 gdk_drawable_unref (current_window);
2964 current_window = NULL;
2967 if (p_grab_window == window)
2968 gdk_pointer_ungrab (msg->time);
2970 if (k_grab_window == window)
2971 gdk_keyboard_ungrab (msg->time);
2973 return_val = window != NULL && !GDK_WINDOW_DESTROYED (window);
2975 if ((window != NULL) && (gdk_root_window != msg->hwnd))
2976 gdk_window_destroy_notify (window);
2981 /* Handle WINTAB events here, as we know that gdkinput.c will
2982 * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
2983 * constants as case labels.
2986 GDK_NOTE (EVENTS, g_print ("WT_PACKET: %#lx %d %#lx\n",
2988 msg->wParam, msg->lParam));
2992 GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %#lx %d %#lx\n",
2994 msg->wParam, msg->lParam));
2998 GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %#lx %#x %d %d\n",
2999 (gulong) msg->hwnd, msg->wParam,
3000 LOWORD (msg->lParam),
3001 HIWORD (msg->lParam)));
3004 event->any.window = window;
3005 return_val = _gdk_input_other_event(event, msg, window);
3010 GDK_NOTE (EVENTS, g_print ("%s: %#lx %#x %#lx\n",
3011 gdk_win32_message_name (msg->message),
3013 msg->wParam, msg->lParam));
3020 if (event->any.window)
3021 gdk_drawable_ref (event->any.window);
3022 if (((event->any.type == GDK_ENTER_NOTIFY) ||
3023 (event->any.type == GDK_LEAVE_NOTIFY)) &&
3024 (event->crossing.subwindow != NULL))
3025 gdk_drawable_ref (event->crossing.subwindow);
3027 GDK_NOTE (EVENTS, print_event (event));
3031 /* Mark this event as having no resources to be freed */
3032 event->any.window = NULL;
3033 event->any.type = GDK_NOTHING;
3037 gdk_drawable_unref (window);
3043 gdk_events_queue (void)
3047 while (!gdk_event_queue_find_first ()
3048 && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3050 GDK_NOTE (EVENTS, g_print ("PeekMessage: %#lx %s\n",
3051 (gulong) msg.hwnd, gdk_win32_message_name (msg.message)));
3053 if (active_imm_msgpump_owner == NULL
3054 || (active_imm_msgpump_owner->lpVtbl->OnTranslateMessage) (active_imm_msgpump_owner, &msg) != S_OK)
3055 TranslateMessage (&msg);
3057 DispatchMessage (&msg);
3062 gdk_event_prepare (GSource *source,
3068 GDK_THREADS_ENTER ();
3072 retval = (gdk_event_queue_find_first () != NULL)
3073 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3075 GDK_THREADS_LEAVE ();
3081 gdk_event_check (GSource *source)
3086 GDK_THREADS_ENTER ();
3088 if (event_poll_fd.revents & G_IO_IN)
3089 retval = (gdk_event_queue_find_first () != NULL)
3090 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3094 GDK_THREADS_LEAVE ();
3100 gdk_event_dispatch (GSource *source,
3101 GSourceFunc callback,
3106 GDK_THREADS_ENTER ();
3109 event = gdk_event_unqueue();
3114 (*gdk_event_func) (event, gdk_event_data);
3116 gdk_event_free (event);
3119 GDK_THREADS_LEAVE ();
3124 /* Sends a ClientMessage to all toplevel client windows */
3126 gdk_event_send_client_message (GdkEvent *event, guint32 xid)
3133 gdk_event_send_clientmessage_toall (GdkEvent *event)
3143 /* Process all messages currently available */
3144 while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3146 TranslateMessage (&msg); /* Translate virt. key codes */
3147 DispatchMessage (&msg); /* Dispatch msg. to window */
3152 #ifdef G_ENABLE_DEBUG
3155 gdk_win32_message_name (UINT msg)
3157 static gchar bfr[100];
3161 #define CASE(x) case x: return #x
3169 CASE (WM_KILLFOCUS);
3171 CASE (WM_SETREDRAW);
3174 CASE (WM_GETTEXTLENGTH);
3177 CASE (WM_QUERYENDSESSION);
3178 CASE (WM_QUERYOPEN);
3179 CASE (WM_ENDSESSION);
3181 CASE (WM_ERASEBKGND);
3182 CASE (WM_SYSCOLORCHANGE);
3183 CASE (WM_SHOWWINDOW);
3184 CASE (WM_WININICHANGE);
3185 CASE (WM_DEVMODECHANGE);
3186 CASE (WM_ACTIVATEAPP);
3187 CASE (WM_FONTCHANGE);
3188 CASE (WM_TIMECHANGE);
3189 CASE (WM_CANCELMODE);
3190 CASE (WM_SETCURSOR);
3191 CASE (WM_MOUSEACTIVATE);
3192 CASE (WM_CHILDACTIVATE);
3193 CASE (WM_QUEUESYNC);
3194 CASE (WM_GETMINMAXINFO);
3195 CASE (WM_PAINTICON);
3196 CASE (WM_ICONERASEBKGND);
3197 CASE (WM_NEXTDLGCTL);
3198 CASE (WM_SPOOLERSTATUS);
3200 CASE (WM_MEASUREITEM);
3201 CASE (WM_DELETEITEM);
3202 CASE (WM_VKEYTOITEM);
3203 CASE (WM_CHARTOITEM);
3206 CASE (WM_SETHOTKEY);
3207 CASE (WM_GETHOTKEY);
3208 CASE (WM_QUERYDRAGICON);
3209 CASE (WM_COMPAREITEM);
3210 CASE (WM_GETOBJECT);
3211 CASE (WM_COMPACTING);
3212 CASE (WM_WINDOWPOSCHANGING);
3213 CASE (WM_WINDOWPOSCHANGED);
3216 CASE (WM_CANCELJOURNAL);
3218 CASE (WM_INPUTLANGCHANGEREQUEST);
3219 CASE (WM_INPUTLANGCHANGE);
3222 CASE (WM_USERCHANGED);
3223 CASE (WM_NOTIFYFORMAT);
3224 CASE (WM_CONTEXTMENU);
3225 CASE (WM_STYLECHANGING);
3226 CASE (WM_STYLECHANGED);
3227 CASE (WM_DISPLAYCHANGE);
3231 CASE (WM_NCDESTROY);
3232 CASE (WM_NCCALCSIZE);
3233 CASE (WM_NCHITTEST);
3235 CASE (WM_NCACTIVATE);
3236 CASE (WM_GETDLGCODE);
3237 CASE (WM_SYNCPAINT);
3238 CASE (WM_NCMOUSEMOVE);
3239 CASE (WM_NCLBUTTONDOWN);
3240 CASE (WM_NCLBUTTONUP);
3241 CASE (WM_NCLBUTTONDBLCLK);
3242 CASE (WM_NCRBUTTONDOWN);
3243 CASE (WM_NCRBUTTONUP);
3244 CASE (WM_NCRBUTTONDBLCLK);
3245 CASE (WM_NCMBUTTONDOWN);
3246 CASE (WM_NCMBUTTONUP);
3247 CASE (WM_NCMBUTTONDBLCLK);
3248 CASE (WM_NCXBUTTONDOWN);
3249 CASE (WM_NCXBUTTONUP);
3250 CASE (WM_NCXBUTTONDBLCLK);
3255 CASE (WM_SYSKEYDOWN);
3258 CASE (WM_SYSDEADCHAR);
3260 CASE (WM_IME_STARTCOMPOSITION);
3261 CASE (WM_IME_ENDCOMPOSITION);
3262 CASE (WM_IME_COMPOSITION);
3263 CASE (WM_INITDIALOG);
3265 CASE (WM_SYSCOMMAND);
3270 CASE (WM_INITMENUPOPUP);
3271 CASE (WM_MENUSELECT);
3273 CASE (WM_ENTERIDLE);
3274 CASE (WM_MENURBUTTONUP);
3276 CASE (WM_MENUGETOBJECT);
3277 CASE (WM_UNINITMENUPOPUP);
3278 CASE (WM_MENUCOMMAND);
3279 CASE (WM_CHANGEUISTATE);
3280 CASE (WM_UPDATEUISTATE);
3281 CASE (WM_QUERYUISTATE);
3282 CASE (WM_CTLCOLORMSGBOX);
3283 CASE (WM_CTLCOLOREDIT);
3284 CASE (WM_CTLCOLORLISTBOX);
3285 CASE (WM_CTLCOLORBTN);
3286 CASE (WM_CTLCOLORDLG);
3287 CASE (WM_CTLCOLORSCROLLBAR);
3288 CASE (WM_CTLCOLORSTATIC);
3289 CASE (WM_MOUSEMOVE);
3290 CASE (WM_LBUTTONDOWN);
3291 CASE (WM_LBUTTONUP);
3292 CASE (WM_LBUTTONDBLCLK);
3293 CASE (WM_RBUTTONDOWN);
3294 CASE (WM_RBUTTONUP);
3295 CASE (WM_RBUTTONDBLCLK);
3296 CASE (WM_MBUTTONDOWN);
3297 CASE (WM_MBUTTONUP);
3298 CASE (WM_MBUTTONDBLCLK);
3299 CASE (WM_MOUSEWHEEL);
3300 CASE (WM_XBUTTONDOWN);
3301 CASE (WM_XBUTTONUP);
3302 CASE (WM_XBUTTONDBLCLK);
3303 CASE (WM_PARENTNOTIFY);
3304 CASE (WM_ENTERMENULOOP);
3305 CASE (WM_EXITMENULOOP);
3308 CASE (WM_CAPTURECHANGED);
3310 CASE (WM_POWERBROADCAST);
3311 CASE (WM_DEVICECHANGE);
3312 CASE (WM_MDICREATE);
3313 CASE (WM_MDIDESTROY);
3314 CASE (WM_MDIACTIVATE);
3315 CASE (WM_MDIRESTORE);
3317 CASE (WM_MDIMAXIMIZE);
3319 CASE (WM_MDICASCADE);
3320 CASE (WM_MDIICONARRANGE);
3321 CASE (WM_MDIGETACTIVE);
3322 CASE (WM_MDISETMENU);
3323 CASE (WM_ENTERSIZEMOVE);
3324 CASE (WM_EXITSIZEMOVE);
3325 CASE (WM_DROPFILES);
3326 CASE (WM_MDIREFRESHMENU);
3327 CASE (WM_IME_SETCONTEXT);
3328 CASE (WM_IME_NOTIFY);
3329 CASE (WM_IME_CONTROL);
3330 CASE (WM_IME_COMPOSITIONFULL);
3331 CASE (WM_IME_SELECT);
3333 CASE (WM_IME_REQUEST);
3334 CASE (WM_IME_KEYDOWN);
3335 CASE (WM_IME_KEYUP);
3336 CASE (WM_MOUSEHOVER);
3337 CASE (WM_MOUSELEAVE);
3338 CASE (WM_NCMOUSEHOVER);
3339 CASE (WM_NCMOUSELEAVE);
3345 CASE (WM_RENDERFORMAT);
3346 CASE (WM_RENDERALLFORMATS);
3347 CASE (WM_DESTROYCLIPBOARD);
3348 CASE (WM_DRAWCLIPBOARD);
3349 CASE (WM_PAINTCLIPBOARD);
3350 CASE (WM_VSCROLLCLIPBOARD);
3351 CASE (WM_SIZECLIPBOARD);
3352 CASE (WM_ASKCBFORMATNAME);
3353 CASE (WM_CHANGECBCHAIN);
3354 CASE (WM_HSCROLLCLIPBOARD);
3355 CASE (WM_QUERYNEWPALETTE);
3356 CASE (WM_PALETTEISCHANGING);
3357 CASE (WM_PALETTECHANGED);
3360 CASE (WM_PRINTCLIENT);
3361 CASE (WM_APPCOMMAND);
3362 CASE (WM_HANDHELDFIRST);
3363 CASE (WM_HANDHELDLAST);
3366 CASE (WM_PENWINFIRST);
3367 CASE (WM_PENWINLAST);
3371 if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST)
3372 sprintf (bfr, "WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST);
3373 else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST)
3374 sprintf (bfr, "WM_AFXFIRST+%d", msg - WM_AFXFIRST);
3375 else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST)
3376 sprintf (bfr, "WM_PENWINFIRST+%d", msg - WM_PENWINFIRST);
3377 else if (msg >= WM_USER && msg <= 0x7FFF)
3378 sprintf (bfr, "WM_USER+%d", msg - WM_USER);
3379 else if (msg >= 0xC000 && msg <= 0xFFFF)
3380 sprintf (bfr, "reg-%#x", msg);
3382 sprintf (bfr, "unk-%#x", msg);
3385 g_assert_not_reached ();
3388 #endif /* G_ENABLE_DEBUG */