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,
101 static gboolean gdk_event_prepare (GSource *source,
103 static gboolean gdk_event_check (GSource *source);
104 static gboolean gdk_event_dispatch (GSource *source,
105 GSourceFunc callback,
108 /* Private variable declarations
111 static GdkWindow *p_grab_window = NULL; /* Window that currently
112 * holds the pointer grab
115 static GdkWindow *k_grab_window = NULL; /* Window the holds the
119 static GList *client_filters; /* Filters for client messages */
121 static gboolean p_grab_automatic;
122 static GdkEventMask p_grab_mask;
123 static gboolean p_grab_owner_events, k_grab_owner_events;
124 static HCURSOR p_grab_cursor;
126 static GSourceFuncs event_funcs = {
133 GPollFD event_poll_fd;
135 static GdkWindow *current_window = NULL;
136 static gint current_x, current_y;
137 static gdouble current_x_root, current_y_root;
138 static UINT gdk_ping_msg;
139 static UINT msh_mousewheel_msg;
140 static gboolean ignore_wm_char = FALSE;
141 static gboolean is_altgr_key = FALSE;
143 static IActiveIMMApp *active_imm_app = NULL;
144 static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
146 typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
147 static PFN_TrackMouseEvent track_mouse_event = NULL;
149 static gboolean use_ime_composition = FALSE;
152 real_window_procedure (HWND hwnd,
157 GdkEventPrivate event;
163 gboolean ret_val_flag;
166 msg.message = message;
169 msg.time = GetTickCount ();
170 pos = GetMessagePos ();
171 msg.pt.x = LOWORD (pos);
172 msg.pt.y = HIWORD (pos);
174 event.flags = GDK_EVENT_PENDING;
175 if (gdk_event_translate (&event.event, &msg, &ret_val_flag, &ret_val))
177 event.flags &= ~GDK_EVENT_PENDING;
179 if (event.event.any.type == GDK_CONFIGURE)
181 /* Compress configure events */
182 GList *list = gdk_queued_events;
185 && (((GdkEvent *)list->data)->any.type != GDK_CONFIGURE
186 || ((GdkEvent *)list->data)->any.window != event.event.any.window))
190 GDK_NOTE (EVENTS, g_print ("... compressing an CONFIGURE event\n"));
192 *((GdkEvent *)list->data) = event.event;
193 gdk_drawable_unref (event.event.any.window);
194 /* Wake up WaitMessage */
195 PostMessage (NULL, gdk_ping_msg, 0, 0);
199 else if (event.event.any.type == GDK_EXPOSE)
201 /* Compress expose events */
202 GList *list = gdk_queued_events;
205 && (((GdkEvent *)list->data)->any.type != GDK_EXPOSE
206 || ((GdkEvent *)list->data)->any.window != event.event.any.window))
212 GDK_NOTE (EVENTS, g_print ("... compressing an EXPOSE event\n"));
213 gdk_rectangle_union (&event.event.expose.area,
214 &((GdkEvent *)list->data)->expose.area,
216 ((GdkEvent *)list->data)->expose.area = u;
217 gdk_drawable_unref (event.event.any.window);
219 /* Wake up WaitMessage */
220 PostMessage (NULL, gdk_ping_msg, 0, 0);
226 eventp = gdk_event_new ();
227 *((GdkEventPrivate *) eventp) = event;
229 /* Philippe Colantoni <colanton@aris.ss.uci.edu> suggests this
230 * in order to handle events while opaque resizing neatly. I
231 * don't want it as default. Set the
232 * GDK_EVENT_FUNC_FROM_WINDOW_PROC env var to get this
235 if (gdk_event_func_from_window_proc && gdk_event_func)
237 GDK_THREADS_ENTER ();
239 (*gdk_event_func) (eventp, gdk_event_data);
240 gdk_event_free (eventp);
242 GDK_THREADS_LEAVE ();
246 gdk_event_queue_append (eventp);
248 /* Wake up WaitMessage */
249 PostMessage (NULL, gdk_ping_msg, 0, 0);
263 if (active_imm_app == NULL
264 || (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
265 return DefWindowProc (hwnd, message, wparam, lparam);
272 gdk_window_procedure (HWND hwnd,
279 GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx %s\n",
280 (gulong) hwnd, gdk_win32_message_name (message)));
282 retval = real_window_procedure (hwnd, message, wparam, lparam);
284 GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx returns %ld\n",
285 (gulong) hwnd, retval));
291 gdk_events_init (void)
295 #ifdef USE_TRACKMOUSEEVENT
296 HMODULE user32, imm32;
297 HINSTANCE commctrl32;
300 gdk_ping_msg = RegisterWindowMessage ("gdk-ping");
301 GDK_NOTE (EVENTS, g_print ("gdk-ping = %#x\n", gdk_ping_msg));
303 /* This is the string MSH_MOUSEWHEEL from zmouse.h,
304 * http://www.microsoft.com/mouse/intellimouse/sdk/zmouse.h
305 * This message is used by mouse drivers than cannot generate WM_MOUSEWHEEL
308 msh_mousewheel_msg = RegisterWindowMessage ("MSWHEEL_ROLLMSG");
309 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL = %#x\n", msh_mousewheel_msg));
311 source = g_source_new (&event_funcs, sizeof (GSource));
312 g_source_set_priority (source, GDK_PRIORITY_EVENTS);
314 event_poll_fd.fd = G_WIN32_MSG_HANDLE;
315 event_poll_fd.events = G_IO_IN;
317 g_source_add_poll (source, &event_poll_fd);
318 g_source_set_can_recurse (source, TRUE);
319 g_source_attach (source, NULL);
321 hres = CoCreateInstance (&CLSID_CActiveIMM,
325 (LPVOID *) &active_imm_app);
329 GDK_NOTE (EVENTS, g_print ("IActiveIMMApp created %p\n",
331 (*active_imm_app->lpVtbl->Activate) (active_imm_app, TRUE);
333 hres = (*active_imm_app->lpVtbl->QueryInterface) (active_imm_app, &IID_IActiveIMMMessagePumpOwner, &active_imm_msgpump_owner);
334 GDK_NOTE (EVENTS, g_print ("IActiveIMMMessagePumpOwner created %p\n",
335 active_imm_msgpump_owner));
336 (active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
339 #ifdef USE_TRACKMOUSEEVENT
340 user32 = GetModuleHandle ("user32.dll");
341 if ((track_mouse_event = GetProcAddress (user32, "TrackMouseEvent")) == NULL)
343 if ((commctrl32 = LoadLibrary ("commctrl32.dll")) != NULL)
344 track_mouse_event = (PFN_TrackMouseEvent)
345 GetProcAddress (commctrl32, "_TrackMouseEvent");
347 if (track_mouse_event != NULL)
348 GDK_NOTE (EVENTS, g_print ("Using TrackMouseEvent to detect leave events\n"));
350 if (IS_WIN_NT () && (windows_version & 0xFF) == 5)
352 /* On Win2k (Beta 3, at least) WM_IME_CHAR doesn't seem to work
353 * correctly for non-Unicode applications. Handle
354 * WM_IME_COMPOSITION with GCS_RESULTSTR instead, fetch the
355 * Unicode char from the IME with ImmGetCompositionStringW().
357 use_ime_composition = TRUE;
362 *--------------------------------------------------------------
365 * Returns if events are pending on the queue.
370 * Returns TRUE if events are pending
374 *--------------------------------------------------------------
378 gdk_events_pending (void)
382 return (gdk_event_queue_find_first() ||
383 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
387 *--------------------------------------------------------------
388 * gdk_event_get_graphics_expose
390 * Waits for a GraphicsExpose or NoExpose event
395 * For GraphicsExpose events, returns a pointer to the event
396 * converted into a GdkEvent Otherwise, returns NULL.
400 *-------------------------------------------------------------- */
403 gdk_event_get_graphics_expose (GdkWindow *window)
408 g_return_val_if_fail (window != NULL, NULL);
410 GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));
413 /* Some nasty bugs here, just return NULL for now. */
416 if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
418 event = gdk_event_new ();
420 if (gdk_event_translate (event, &msg, NULL, NULL))
423 gdk_event_free (event);
431 event_mask_string (GdkEventMask mask)
433 static char bfr[500];
438 if (mask & GDK_##x##_MASK) \
439 p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
442 BIT(POINTER_MOTION_HINT);
455 BIT(PROPERTY_CHANGE);
456 BIT(VISIBILITY_NOTIFY);
467 *--------------------------------------------------------------
470 * Grabs the pointer to a specific window
473 * "window" is the window which will receive the grab
474 * "owner_events" specifies whether events will be reported as is,
475 * or relative to "window"
476 * "event_mask" masks only interesting events
477 * "confine_to" limits the cursor movement to the specified window
478 * "cursor" changes the cursor for the duration of the grab
479 * "time" specifies the time
484 * requires a corresponding call to gdk_pointer_ungrab
486 *--------------------------------------------------------------
490 gdk_pointer_grab (GdkWindow *window,
491 gboolean owner_events,
492 GdkEventMask event_mask,
493 GdkWindow *confine_to,
497 HWND hwnd_confined_to;
499 GdkCursorPrivate *cursor_private;
502 g_return_val_if_fail (window != NULL, 0);
503 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
504 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
506 cursor_private = (GdkCursorPrivate*) cursor;
508 if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
509 hwnd_confined_to = NULL;
511 hwnd_confined_to = GDK_WINDOW_HWND (confine_to);
516 hcursor = cursor_private->hcursor;
518 return_val = _gdk_input_grab_pointer (window,
524 if (return_val == GDK_GRAB_SUCCESS)
526 if (!GDK_WINDOW_DESTROYED (window))
528 GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#lx %s %#lx %s\n",
529 (gulong) GDK_WINDOW_HWND (window),
530 (owner_events ? "TRUE" : "FALSE"),
532 event_mask_string (event_mask)));
533 p_grab_mask = event_mask;
534 p_grab_owner_events = (owner_events != 0);
535 p_grab_automatic = FALSE;
538 SetCapture (GDK_WINDOW_HWND (window));
540 return_val = GDK_GRAB_SUCCESS;
543 return_val = GDK_GRAB_ALREADY_GRABBED;
546 if (return_val == GDK_GRAB_SUCCESS)
548 p_grab_window = window;
549 p_grab_cursor = hcursor;
556 *--------------------------------------------------------------
559 * Releases any pointer grab
567 *--------------------------------------------------------------
571 gdk_pointer_ungrab (guint32 time)
573 GDK_NOTE (EVENTS, g_print ("gdk_pointer_ungrab\n"));
575 _gdk_input_ungrab_pointer (time);
578 if (GetCapture () != NULL)
582 p_grab_window = NULL;
586 *--------------------------------------------------------------
587 * find_window_for_pointer_event
589 * Find the window a pointer event (mouse up, down, move) should
590 * be reported to. If the return value != reported_window then
591 * the ref count of reported_window will be decremented and the
592 * ref count of the return value will be incremented.
596 * "reported_window" is the gdk window the xevent was reported relative to
597 * "xevent" is the win32 message
603 *--------------------------------------------------------------
607 find_window_for_pointer_event (GdkWindow* reported_window,
613 GdkWindow* other_window;
615 if (p_grab_window == NULL || !p_grab_owner_events)
616 return reported_window;
618 points = MAKEPOINTS (msg->lParam);
621 ClientToScreen (msg->hwnd, &pt);
623 GDK_NOTE (EVENTS, g_print ("Finding window for grabbed pointer event at (%ld, %ld)\n",
626 hwnd = WindowFromPoint (pt);
628 return reported_window;
629 other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
630 if (other_window == NULL)
631 return reported_window;
633 GDK_NOTE (EVENTS, g_print ("Found window %#x for point (%ld, %ld)\n",
634 (guint) hwnd, pt.x, pt.y));
636 gdk_window_unref (reported_window);
637 gdk_window_ref (other_window);
643 *--------------------------------------------------------------
644 * gdk_pointer_is_grabbed
646 * Tell wether there is an active x pointer grab in effect
654 *--------------------------------------------------------------
658 gdk_pointer_is_grabbed (void)
660 return p_grab_window != NULL;
664 *--------------------------------------------------------------
667 * Grabs the keyboard to a specific window
670 * "window" is the window which will receive the grab
671 * "owner_events" specifies whether events will be reported as is,
672 * or relative to "window"
673 * "time" specifies the time
678 * requires a corresponding call to gdk_keyboard_ungrab
680 *--------------------------------------------------------------
684 gdk_keyboard_grab (GdkWindow *window,
685 gboolean owner_events,
690 g_return_val_if_fail (window != NULL, 0);
691 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
693 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#lx\n",
694 (gulong) GDK_WINDOW_HWND (window)));
696 if (!GDK_WINDOW_DESTROYED (window))
698 k_grab_owner_events = owner_events != 0;
699 return_val = GDK_GRAB_SUCCESS;
702 return_val = GDK_GRAB_ALREADY_GRABBED;
704 if (return_val == GDK_GRAB_SUCCESS)
705 k_grab_window = window;
711 *--------------------------------------------------------------
712 * gdk_keyboard_ungrab
714 * Releases any keyboard grab
722 *--------------------------------------------------------------
726 gdk_keyboard_ungrab (guint32 time)
728 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));
730 k_grab_window = NULL;
733 static GdkFilterReturn
734 gdk_event_apply_filters (MSG *msg,
738 GdkEventFilter *filter;
740 GdkFilterReturn result;
746 filter = (GdkEventFilter *) tmp_list->data;
748 result = (*filter->function) (msg, event, filter->data);
749 if (result != GDK_FILTER_CONTINUE)
752 tmp_list = tmp_list->next;
755 return GDK_FILTER_CONTINUE;
759 gdk_add_client_message_filter (GdkAtom message_type,
763 GdkClientFilter *filter = g_new (GdkClientFilter, 1);
765 filter->type = message_type;
766 filter->function = func;
769 client_filters = g_list_prepend (client_filters, filter);
772 /* Thanks to Markus G. Kuhn <mkuhn@acm.org> for the ksysym<->Unicode
773 * mapping functions, from the xterm sources.
777 build_key_event_state (GdkEvent *event)
779 if (GetKeyState (VK_SHIFT) < 0)
780 event->key.state |= GDK_SHIFT_MASK;
781 if (GetKeyState (VK_CAPITAL) & 0x1)
782 event->key.state |= GDK_LOCK_MASK;
785 if (GetKeyState (VK_CONTROL) < 0)
787 event->key.state |= GDK_CONTROL_MASK;
789 if (event->key.keyval < ' ')
790 event->key.keyval += '@';
794 else if (event->key.keyval < ' ')
796 event->key.state |= GDK_CONTROL_MASK;
797 event->key.keyval += '@';
800 if (GetKeyState (VK_MENU) < 0)
801 event->key.state |= GDK_MOD1_MASK;
806 build_pointer_event_state (MSG *msg)
811 if (msg->wParam & MK_CONTROL)
812 state |= GDK_CONTROL_MASK;
813 if (msg->wParam & MK_LBUTTON)
814 state |= GDK_BUTTON1_MASK;
815 if (msg->wParam & MK_MBUTTON)
816 state |= GDK_BUTTON2_MASK;
817 if (msg->wParam & MK_RBUTTON)
818 state |= GDK_BUTTON3_MASK;
819 if (msg->wParam & MK_SHIFT)
820 state |= GDK_SHIFT_MASK;
821 if (GetKeyState (VK_MENU) < 0)
822 state |= GDK_MOD1_MASK;
823 if (GetKeyState (VK_CAPITAL) & 0x1)
824 state |= GDK_LOCK_MASK;
830 build_keypress_event (GdkWindowImplWin32 *impl,
835 gint i, bytecount, ucount, ucleft, len;
836 guchar buf[100], *bp;
837 wchar_t wbuf[100], *wcp;
839 event->key.type = GDK_KEY_PRESS;
840 event->key.time = msg->time;
841 event->key.state = 0;
843 if (msg->message == WM_IME_COMPOSITION)
845 himc = ImmGetContext (msg->hwnd);
847 bytecount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
848 wbuf, sizeof (wbuf));
849 ucount = bytecount / 2;
853 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
855 bytecount = MIN ((msg->lParam & 0xFFFF), sizeof (buf));
856 for (i = 0; i < bytecount; i++)
857 buf[i] = msg->wParam;
859 else /* WM_IME_CHAR */
861 event->key.keyval = GDK_VoidSymbol;
862 if (msg->wParam & 0xFF00)
864 /* Contrary to some versions of the documentation,
865 * the lead byte is the most significant byte.
867 buf[0] = ((msg->wParam >> 8) & 0xFF);
868 buf[1] = (msg->wParam & 0xFF);
873 buf[0] = (msg->wParam & 0xFF);
878 /* Convert from the window's current code page
879 * to Unicode. Then convert to UTF-8.
880 * We don't handle the surrogate stuff. Should we?
882 ucount = MultiByteToWideChar (impl->charset_info.ciACP,
884 wbuf, sizeof (wbuf) / sizeof (wbuf[0]));
888 event->key.keyval = GDK_VoidSymbol;
889 else if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
891 if (msg->wParam < ' ')
893 event->key.keyval = msg->wParam + '@';
894 /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
897 event->key.state |= GDK_CONTROL_MASK;
900 event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
903 build_key_event_state (event);
905 /* Build UTF-8 string */
921 event->key.string = g_malloc (len + 1);
922 event->key.length = len;
926 bp = event->key.string;
952 case 3: bp[2] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
953 case 2: bp[1] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
954 case 1: bp[0] = c | first;
957 for (i = len - 1; i > 0; --i)
959 bp[i] = (c & 0x3f) | 0x80;
971 build_keyrelease_event (GdkWindowImplWin32 *impl,
978 event->key.type = GDK_KEY_RELEASE;
979 event->key.time = msg->time;
980 event->key.state = 0;
982 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
983 if (msg->wParam < ' ')
984 event->key.keyval = msg->wParam + '@';
988 MultiByteToWideChar (impl->charset_info.ciACP,
989 0, &buf, 1, &wbuf, 1);
991 event->key.keyval = gdk_unicode_to_keyval (wbuf);
994 event->key.keyval = GDK_VoidSymbol;
995 build_key_event_state (event);
996 event->key.string = NULL;
997 event->key.length = 0;
1001 print_event_state (gint state)
1003 if (state & GDK_SHIFT_MASK)
1005 if (state & GDK_LOCK_MASK)
1007 if (state & GDK_CONTROL_MASK)
1008 g_print ("CONTROL ");
1009 if (state & GDK_MOD1_MASK)
1011 if (state & GDK_BUTTON1_MASK)
1012 g_print ("BUTTON1 ");
1013 if (state & GDK_BUTTON2_MASK)
1014 g_print ("BUTTON2 ");
1015 if (state & GDK_BUTTON3_MASK)
1016 g_print ("BUTTON3 ");
1020 print_event (GdkEvent *event)
1022 gchar *escaped, *kvname;
1024 switch (event->any.type)
1026 case GDK_NOTHING: g_print ("GDK_NOTHING "); break;
1027 case GDK_DELETE: g_print ("GDK_DELETE "); break;
1028 case GDK_DESTROY: g_print ("GDK_DESTROY "); break;
1029 case GDK_EXPOSE: g_print ("GDK_EXPOSE "); break;
1030 case GDK_MOTION_NOTIFY: g_print ("GDK_MOTION_NOTIFY "); break;
1031 case GDK_BUTTON_PRESS: g_print ("GDK_BUTTON_PRESS "); break;
1032 case GDK_2BUTTON_PRESS: g_print ("GDK_2BUTTON_PRESS "); break;
1033 case GDK_3BUTTON_PRESS: g_print ("GDK_3BUTTON_PRESS "); break;
1034 case GDK_BUTTON_RELEASE: g_print ("GDK_BUTTON_RELEASE "); break;
1035 case GDK_KEY_PRESS: g_print ("GDK_KEY_PRESS "); break;
1036 case GDK_KEY_RELEASE: g_print ("GDK_KEY_RELEASE "); break;
1037 case GDK_ENTER_NOTIFY: g_print ("GDK_ENTER_NOTIFY "); break;
1038 case GDK_LEAVE_NOTIFY: g_print ("GDK_LEAVE_NOTIFY "); break;
1039 case GDK_FOCUS_CHANGE: g_print ("GDK_FOCUS_CHANGE "); break;
1040 case GDK_CONFIGURE: g_print ("GDK_CONFIGURE "); break;
1041 case GDK_MAP: g_print ("GDK_MAP "); break;
1042 case GDK_UNMAP: g_print ("GDK_UNMAP "); break;
1043 case GDK_PROPERTY_NOTIFY: g_print ("GDK_PROPERTY_NOTIFY "); break;
1044 case GDK_SELECTION_CLEAR: g_print ("GDK_SELECTION_CLEAR "); break;
1045 case GDK_SELECTION_REQUEST: g_print ("GDK_SELECTION_REQUEST "); break;
1046 case GDK_SELECTION_NOTIFY: g_print ("GDK_SELECTION_NOTIFY "); break;
1047 case GDK_PROXIMITY_IN: g_print ("GDK_PROXIMITY_IN "); break;
1048 case GDK_PROXIMITY_OUT: g_print ("GDK_PROXIMITY_OUT "); break;
1049 case GDK_DRAG_ENTER: g_print ("GDK_DRAG_ENTER "); break;
1050 case GDK_DRAG_LEAVE: g_print ("GDK_DRAG_LEAVE "); break;
1051 case GDK_DRAG_MOTION: g_print ("GDK_DRAG_MOTION "); break;
1052 case GDK_DRAG_STATUS: g_print ("GDK_DRAG_STATUS "); break;
1053 case GDK_DROP_START: g_print ("GDK_DROP_START "); break;
1054 case GDK_DROP_FINISHED: g_print ("GDK_DROP_FINISHED "); break;
1055 case GDK_CLIENT_EVENT: g_print ("GDK_CLIENT_EVENT "); break;
1056 case GDK_VISIBILITY_NOTIFY: g_print ("GDK_VISIBILITY_NOTIFY "); break;
1057 case GDK_NO_EXPOSE: g_print ("GDK_NO_EXPOSE "); break;
1058 case GDK_SCROLL: g_print ("GDK_SCROLL "); break;
1060 g_print ("%#lx ", (gulong) GDK_WINDOW_HWND (event->any.window));
1062 switch (event->any.type)
1065 g_print ("%dx%d@+%d+%d %d",
1066 event->expose.area.width,
1067 event->expose.area.height,
1068 event->expose.area.x,
1069 event->expose.area.y,
1070 event->expose.count);
1072 case GDK_MOTION_NOTIFY:
1073 g_print ("(%.4g,%.4g) %s",
1074 event->motion.x, event->motion.y,
1075 event->motion.is_hint ? "HINT " : "");
1076 print_event_state (event->motion.state);
1078 case GDK_BUTTON_PRESS:
1079 case GDK_2BUTTON_PRESS:
1080 case GDK_3BUTTON_PRESS:
1081 case GDK_BUTTON_RELEASE:
1082 g_print ("%d (%.4g,%.4g) ",
1083 event->button.button,
1084 event->button.x, event->button.y);
1085 print_event_state (event->button.state);
1088 case GDK_KEY_RELEASE:
1089 if (event->key.length == 0)
1090 escaped = g_strdup ("");
1092 escaped = g_strescape (event->key.string, NULL);
1093 kvname = gdk_keyval_name (event->key.keyval);
1094 g_print ("%s %d:\"%s\" ",
1095 (kvname ? kvname : "??"),
1099 print_event_state (event->key.state);
1101 case GDK_ENTER_NOTIFY:
1102 case GDK_LEAVE_NOTIFY:
1104 (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
1105 (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
1106 (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
1111 (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
1112 (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
1113 (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
1114 (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
1116 print_event_state (event->scroll.state);
1127 /* Old implementation */
1130 synthesize_crossing_events (GdkWindow *window,
1135 /* If we are not using TrackMouseEvent, generate a leave notify
1136 * event if necessary
1138 if (track_mouse_event == NULL
1140 && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1142 GDK_NOTE (EVENTS, g_print ("synthesizing LEAVE_NOTIFY event\n"));
1144 event = gdk_event_new ();
1145 event->crossing.type = GDK_LEAVE_NOTIFY;
1146 event->crossing.window = current_window;
1147 gdk_drawable_ref (event->crossing.window);
1148 event->crossing.subwindow = NULL;
1149 event->crossing.time = msg->time;
1150 event->crossing.x = current_x;
1151 event->crossing.y = current_y;
1152 event->crossing.x_root = current_x_root;
1153 event->crossing.y_root = current_y_root;
1154 event->crossing.mode = GDK_CROSSING_NORMAL;
1155 if (IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
1156 event->crossing.detail = GDK_NOTIFY_INFERIOR;
1157 else if (IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
1158 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1160 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
1162 event->crossing.focus = TRUE; /* ??? */
1163 event->crossing.state = 0; /* ??? */
1165 gdk_event_queue_append (event);
1166 GDK_NOTE (EVENTS, print_event (event));
1169 if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK)
1171 GDK_NOTE (EVENTS, g_print ("synthesizing ENTER_NOTIFY event\n"));
1173 event = gdk_event_new ();
1174 event->crossing.type = GDK_ENTER_NOTIFY;
1175 event->crossing.window = window;
1176 gdk_drawable_ref (event->crossing.window);
1177 event->crossing.subwindow = NULL;
1178 event->crossing.time = msg->time;
1179 event->crossing.x = LOWORD (msg->lParam);
1180 event->crossing.y = HIWORD (msg->lParam);
1181 event->crossing.x_root = (gfloat) msg->pt.x;
1182 event->crossing.y_root = (gfloat) msg->pt.y;
1183 event->crossing.mode = GDK_CROSSING_NORMAL;
1185 && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
1186 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1187 else if (current_window
1188 && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
1189 event->crossing.detail = GDK_NOTIFY_INFERIOR;
1191 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
1193 event->crossing.focus = TRUE; /* ??? */
1194 event->crossing.state = 0; /* ??? */
1196 gdk_event_queue_append (event);
1198 GDK_NOTE (EVENTS, print_event (event));
1200 if (GDK_WINDOW_OBJECT (window)->extension_events != 0)
1201 _gdk_input_enter_event (&event->crossing, window);
1205 gdk_drawable_unref (current_window);
1206 current_window = window;
1207 gdk_drawable_ref (current_window);
1208 #ifdef USE_TRACKMOUSEEVENT
1209 if (track_mouse_event != NULL)
1211 TRACKMOUSEEVENT tme;
1213 tme.cbSize = sizeof (TRACKMOUSEEVENT);
1214 tme.dwFlags = TME_LEAVE;
1215 tme.hwndTrack = GDK_WINDOW_HWND (current_window);
1216 tme.dwHoverTime = HOVER_DEFAULT;
1218 (*track_mouse_event) (&tme);
1225 /* New, improved implementation. */
1228 gdk_window_is_child (GdkWindow *parent,
1231 if (parent == NULL || window == NULL)
1234 return (gdk_window_get_parent (window) == parent ||
1235 gdk_window_is_child (parent, gdk_window_get_parent (window)));
1239 synthesize_enter_or_leave_event (GdkWindow *window,
1242 GdkNotifyType detail,
1248 event = gdk_event_new ();
1249 event->crossing.type = type;
1250 event->crossing.window = window;
1251 event->crossing.send_event = FALSE;
1252 gdk_window_ref (event->crossing.window);
1253 event->crossing.subwindow = NULL;
1254 event->crossing.time = msg->time;
1255 event->crossing.x = x;
1256 event->crossing.y = y;
1257 event->crossing.x_root = msg->pt.x;
1258 event->crossing.y_root = msg->pt.y;
1259 event->crossing.mode = GDK_CROSSING_NORMAL;
1260 event->crossing.detail = detail;
1261 event->crossing.focus = TRUE; /* ??? */
1262 event->crossing.state = 0; /* ??? */
1264 gdk_event_queue_append (event);
1266 if (type == GDK_ENTER_NOTIFY
1267 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
1268 _gdk_input_enter_event (&event->crossing, window);
1270 GDK_NOTE (EVENTS, print_event (event));
1274 synthesize_leave_event (GdkWindow *window,
1276 GdkNotifyType detail)
1280 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1283 /* Leave events are at (current_x,current_y) in current_window */
1285 if (current_window != window)
1289 ClientToScreen (GDK_WINDOW_HWND (current_window), &pt);
1290 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1291 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, pt.x, pt.y);
1294 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, current_x, current_y);
1299 synthesize_enter_event (GdkWindow *window,
1301 GdkNotifyType detail)
1305 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK))
1308 /* Enter events are at LOWORD (msg->lParam), HIWORD
1309 * (msg->lParam) in msg->hwnd */
1311 pt.x = LOWORD (msg->lParam);
1312 pt.y = HIWORD (msg->lParam);
1313 if (msg->hwnd != GDK_WINDOW_HWND (window))
1315 ClientToScreen (msg->hwnd, &pt);
1316 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1318 synthesize_enter_or_leave_event (window, msg, GDK_ENTER_NOTIFY, detail, pt.x, pt.y);
1322 synthesize_enter_events (GdkWindow *from,
1325 GdkNotifyType detail)
1327 GdkWindow *prev = gdk_window_get_parent (to);
1330 synthesize_enter_events (from, prev, msg, detail);
1331 synthesize_enter_event (to, msg, detail);
1335 synthesize_leave_events (GdkWindow *from,
1338 GdkNotifyType detail)
1340 GdkWindow *next = gdk_window_get_parent (from);
1342 synthesize_leave_event (from, msg, detail);
1344 synthesize_leave_events (next, to, msg, detail);
1348 synthesize_crossing_events (GdkWindow *window,
1351 GdkWindow *intermediate, *tem, *common_ancestor;
1353 if (gdk_window_is_child (current_window, window))
1355 /* Pointer has moved to an inferior window. */
1356 synthesize_leave_event (current_window, msg, GDK_NOTIFY_INFERIOR);
1358 /* If there are intermediate windows, generate ENTER_NOTIFY
1361 intermediate = gdk_window_get_parent (window);
1362 if (intermediate != current_window)
1364 synthesize_enter_events (current_window, intermediate, msg, GDK_NOTIFY_VIRTUAL);
1367 synthesize_enter_event (window, msg, GDK_NOTIFY_ANCESTOR);
1369 else if (gdk_window_is_child (window, current_window))
1371 /* Pointer has moved to an ancestor window. */
1372 synthesize_leave_event (current_window, msg, GDK_NOTIFY_ANCESTOR);
1374 /* If there are intermediate windows, generate LEAVE_NOTIFY
1377 intermediate = gdk_window_get_parent (current_window);
1378 if (intermediate != window)
1380 synthesize_leave_events (intermediate, window, msg, GDK_NOTIFY_VIRTUAL);
1383 else if (current_window)
1385 /* Find least common ancestor of current_window and window */
1386 tem = current_window;
1388 common_ancestor = gdk_window_get_parent (tem);
1389 tem = common_ancestor;
1390 } while (common_ancestor &&
1391 !gdk_window_is_child (common_ancestor, window));
1392 if (common_ancestor)
1394 synthesize_leave_event (current_window, msg, GDK_NOTIFY_NONLINEAR);
1395 intermediate = gdk_window_get_parent (current_window);
1396 if (intermediate != common_ancestor)
1398 synthesize_leave_events (intermediate, common_ancestor,
1399 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1401 intermediate = gdk_window_get_parent (window);
1402 if (intermediate != common_ancestor)
1404 synthesize_enter_events (common_ancestor, intermediate,
1405 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1407 synthesize_enter_event (window, msg, GDK_NOTIFY_NONLINEAR);
1412 /* Dunno where we are coming from */
1413 synthesize_enter_event (window, msg, GDK_NOTIFY_UNKNOWN);
1417 gdk_window_unref (current_window);
1418 current_window = window;
1419 gdk_window_ref (current_window);
1425 translate_mouse_coords (GdkWindow *window1,
1431 pt.x = LOWORD (msg->lParam);
1432 pt.y = HIWORD (msg->lParam);
1433 ClientToScreen (GDK_WINDOW_HWND (window1), &pt);
1434 ScreenToClient (GDK_WINDOW_HWND (window2), &pt);
1435 msg->lParam = MAKELPARAM (pt.x, pt.y);
1436 GDK_NOTE (EVENTS, g_print ("...new coords are (%ld,%ld)\n", pt.x, pt.y));
1440 propagate (GdkWindow **window,
1442 GdkWindow *grab_window,
1443 gboolean grab_owner_events,
1445 gboolean (*doesnt_want_it) (gint mask,
1448 if (grab_window != NULL && !grab_owner_events)
1450 /* Event source is grabbed with owner_events FALSE */
1451 GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE, "));
1452 if ((*doesnt_want_it) (grab_mask, msg))
1454 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1459 GDK_NOTE (EVENTS, g_print ("...sending to grabber %#lx\n",
1460 (gulong) GDK_WINDOW_HWND (grab_window)));
1461 gdk_drawable_unref (*window);
1462 *window = grab_window;
1463 gdk_drawable_ref (*window);
1469 if ((*doesnt_want_it) (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (*window)->impl)->event_mask, msg))
1471 /* Owner doesn't want it, propagate to parent. */
1472 if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == gdk_parent_root)
1474 /* No parent; check if grabbed */
1475 if (grab_window != NULL)
1477 /* Event source is grabbed with owner_events TRUE */
1478 GDK_NOTE (EVENTS, g_print ("...undelivered, but grabbed\n"));
1479 if ((*doesnt_want_it) (grab_mask, msg))
1481 /* Grabber doesn't want it either */
1482 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1489 g_print ("...sending to grabber %#lx\n",
1490 (gulong) GDK_WINDOW_HWND (grab_window)));
1491 gdk_drawable_unref (*window);
1492 *window = grab_window;
1493 gdk_drawable_ref (*window);
1499 GDK_NOTE (EVENTS, g_print ("...undelivered\n"));
1505 gdk_drawable_unref (*window);
1506 *window = GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent);
1507 gdk_drawable_ref (*window);
1508 GDK_NOTE (EVENTS, g_print ("...propagating to %#lx\n",
1509 (gulong) GDK_WINDOW_HWND (*window)));
1510 /* The only branch where we actually continue the loop */
1519 doesnt_want_key (gint mask,
1522 return (((msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
1523 && !(mask & GDK_KEY_RELEASE_MASK))
1525 ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1526 && !(mask & GDK_KEY_PRESS_MASK)));
1530 doesnt_want_char (gint mask,
1533 return !(mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK));
1537 doesnt_want_button_press (gint mask,
1540 return !(mask & GDK_BUTTON_PRESS_MASK);
1544 doesnt_want_button_release (gint mask,
1547 return !(mask & GDK_BUTTON_RELEASE_MASK);
1551 doesnt_want_button_motion (gint mask,
1554 return !((mask & GDK_POINTER_MOTION_MASK)
1555 || ((msg->wParam & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))
1556 && (mask & GDK_BUTTON_MOTION_MASK))
1557 || ((msg->wParam & MK_LBUTTON)
1558 && (mask & GDK_BUTTON1_MOTION_MASK))
1559 || ((msg->wParam & MK_MBUTTON)
1560 && (mask & GDK_BUTTON2_MOTION_MASK))
1561 || ((msg->wParam & MK_RBUTTON)
1562 && (mask & GDK_BUTTON3_MOTION_MASK)));
1566 doesnt_want_scroll (gint mask,
1570 return !(mask & GDK_SCROLL_MASK);
1572 return !(mask & GDK_BUTTON_PRESS_MASK);
1577 decode_key_lparam (LPARAM lParam)
1579 static char buf[100];
1582 if (HIWORD (lParam) & KF_UP)
1583 p += sprintf (p, "KF_UP ");
1584 if (HIWORD (lParam) & KF_REPEAT)
1585 p += sprintf (p, "KF_REPEAT ");
1586 if (HIWORD (lParam) & KF_ALTDOWN)
1587 p += sprintf (p, "KF_ALTDOWN ");
1588 if (HIWORD (lParam) & KF_EXTENDED)
1589 p += sprintf (p, "KF_EXTENDED ");
1590 p += sprintf (p, "sc%d rep%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
1596 gdk_event_translate (GdkEvent *event,
1598 gboolean *ret_val_flagp,
1603 PAINTSTRUCT paintstruct;
1616 * window_impl == GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)
1619 GdkWindowImplWin32 *window_impl;
1620 #define ASSIGN_WINDOW(rhs) \
1622 window_impl = (window ? GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl) : NULL))
1624 GdkWindow *orig_window, *new_window;
1625 GdkColormapPrivateWin32 *colormap_private;
1627 GdkPixmapImplWin32 *pixmap_impl;
1633 gboolean return_val;
1638 *ret_val_flagp = FALSE;
1640 ASSIGN_WINDOW (gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd));
1641 orig_window = window;
1643 event->any.window = window;
1645 /* InSendMessage() does not really mean the same as X11's send_event flag,
1646 * but it is close enough, says jpe@archaeopteryx.com.
1648 event->any.send_event = InSendMessage ();
1652 /* Handle WM_QUIT here ? */
1653 if (msg->message == WM_QUIT)
1655 GDK_NOTE (EVENTS, g_print ("WM_QUIT: %d\n", msg->wParam));
1658 else if (msg->message == WM_MOVE
1659 || msg->message == WM_SIZE)
1661 /* It's quite normal to get these messages before we have
1662 * had time to register the window in our lookup table, or
1663 * when the window is being destroyed and we already have
1664 * removed it. Repost the same message to our queue so that
1665 * we will get it later when we are prepared.
1667 GDK_NOTE(MISC, g_print("gdk_event_translate: %#lx %s posted.\n",
1669 msg->message == WM_MOVE ?
1670 "WM_MOVE" : "WM_SIZE"));
1672 PostMessage (msg->hwnd, msg->message,
1673 msg->wParam, msg->lParam);
1675 #ifndef WITHOUT_WM_CREATE
1676 else if (WM_CREATE == msg->message)
1678 window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
1679 GDK_WINDOW_HWND (window) = msg->hwnd;
1680 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: created %#x\n",
1681 (guint) msg->hwnd));
1683 /* This should handle allmost all the other window==NULL cases.
1684 * This code is executed while gdk_window_new is in it's
1685 * CreateWindowEx call.
1686 * Don't insert xid there a second time, if it's done here.
1688 gdk_drawable_ref (window);
1689 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND(window), window);
1694 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: %s for %#x (NULL)\n",
1695 gdk_win32_message_name(msg->message),
1696 (guint) msg->hwnd));
1702 gdk_drawable_ref (window);
1704 if (!GDK_WINDOW_DESTROYED (window))
1706 /* Check for filters for this window */
1707 GdkFilterReturn result;
1709 result = gdk_event_apply_filters
1710 (msg, event, GDK_WINDOW_OBJECT (window)->filters);
1712 if (result != GDK_FILTER_CONTINUE)
1714 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1719 if (msg->message == gdk_selection_notify_msg)
1721 GDK_NOTE (EVENTS, g_print ("gdk_selection_notify_msg: %#lx\n",
1722 (gulong) msg->hwnd));
1724 event->selection.type = GDK_SELECTION_NOTIFY;
1725 event->selection.window = window;
1726 event->selection.selection = msg->wParam;
1727 event->selection.target = msg->lParam;
1728 event->selection.property = gdk_selection_property;
1729 event->selection.time = msg->time;
1731 return_val = !GDK_WINDOW_DESTROYED (window);
1735 else if (msg->message == gdk_selection_request_msg)
1737 GDK_NOTE (EVENTS, g_print ("gdk_selection_request_msg: %#lx\n",
1738 (gulong) msg->hwnd));
1740 event->selection.type = GDK_SELECTION_REQUEST;
1741 event->selection.window = window;
1742 event->selection.selection = gdk_clipboard_atom;
1743 event->selection.target = GDK_TARGET_STRING;
1744 event->selection.property = gdk_selection_property;
1745 event->selection.requestor = (guint32) msg->hwnd;
1746 event->selection.time = msg->time;
1748 return_val = !GDK_WINDOW_DESTROYED (window);
1752 else if (msg->message == gdk_selection_clear_msg)
1754 GDK_NOTE (EVENTS, g_print ("gdk_selection_clear_msg: %#lx\n",
1755 (gulong) msg->hwnd));
1757 event->selection.type = GDK_SELECTION_CLEAR;
1758 event->selection.window = window;
1759 event->selection.selection = msg->wParam;
1760 event->selection.time = msg->time;
1762 return_val = !GDK_WINDOW_DESTROYED (window);
1766 else if (msg->message == msh_mousewheel_msg)
1768 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %#lx %d\n",
1769 (gulong) msg->hwnd, msg->wParam));
1771 event->scroll.type = GDK_SCROLL;
1773 /* MSG_MOUSEWHEEL is delivered to the foreground window. Work
1774 * around that. Also, the position is in screen coordinates, not
1775 * client coordinates as with the button messages.
1777 pt.x = LOWORD (msg->lParam);
1778 pt.y = HIWORD (msg->lParam);
1779 if ((hwnd = WindowFromPoint (pt)) == NULL)
1783 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
1786 if (new_window != window)
1788 gdk_drawable_unref (window);
1789 ASSIGN_WINDOW (new_window);
1790 gdk_drawable_ref (window);
1793 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
1794 && gdk_input_ignore_core)
1796 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
1800 if (!propagate (&window, msg,
1801 p_grab_window, p_grab_owner_events, p_grab_mask,
1802 doesnt_want_scroll))
1805 ASSIGN_WINDOW (window);
1807 ScreenToClient (msg->hwnd, &pt);
1808 event->button.window = window;
1809 event->scroll.direction = ((int) msg->wParam > 0) ?
1810 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
1811 event->scroll.window = window;
1812 event->scroll.time = msg->time;
1813 event->scroll.x = (gint16) pt.x;
1814 event->scroll.y = (gint16) pt.y;
1815 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
1816 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
1817 event->scroll.state = 0; /* No state information with MSH_MOUSEWHEEL */
1818 event->scroll.device = gdk_core_pointer;
1819 return_val = !GDK_WINDOW_DESTROYED (window);
1826 GdkFilterReturn result = GDK_FILTER_CONTINUE;
1828 tmp_list = client_filters;
1831 GdkClientFilter *filter = tmp_list->data;
1832 if (filter->type == msg->message)
1834 GDK_NOTE (EVENTS, g_print ("client filter matched\n"));
1835 event->any.window = window;
1836 result = (*filter->function) (msg, event, filter->data);
1839 case GDK_FILTER_REMOVE:
1843 case GDK_FILTER_TRANSLATE:
1847 case GDK_FILTER_CONTINUE:
1849 event->client.type = GDK_CLIENT_EVENT;
1850 event->client.window = window;
1851 event->client.message_type = msg->message;
1852 event->client.data_format = 0;
1853 event->client.data.l[0] = msg->wParam;
1854 event->client.data.l[1] = msg->lParam;
1859 tmp_list = tmp_list->next;
1863 switch (msg->message)
1865 case WM_INPUTLANGCHANGE:
1867 g_print ("WM_INPUTLANGCHANGE: %#lx charset %lu locale %lx\n",
1868 (gulong) msg->hwnd, (gulong) msg->wParam, msg->lParam));
1869 window_impl->input_locale = (HKL) msg->lParam;
1870 TranslateCharsetInfo ((DWORD FAR *) msg->wParam,
1871 &window_impl->charset_info,
1878 g_print ("WM_SYSKEY%s: %#lx %s %#x %s\n",
1879 (msg->message == WM_SYSKEYUP ? "UP" : "DOWN"),
1881 (GetKeyNameText (msg->lParam, buf,
1885 decode_key_lparam (msg->lParam)));
1887 /* Let the system handle Alt-Tab and Alt-Enter */
1888 if (msg->wParam == VK_TAB
1889 || msg->wParam == VK_RETURN
1890 || msg->wParam == VK_F4)
1892 /* If posted without us having keyboard focus, ignore */
1893 if (!(msg->lParam & 0x20000000))
1896 /* don't generate events for just the Alt key */
1897 if (msg->wParam == VK_MENU)
1900 /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
1906 g_print ("WM_KEY%s: %#lx %s %#x %s\n",
1907 (msg->message == WM_KEYUP ? "UP" : "DOWN"),
1909 (GetKeyNameText (msg->lParam, buf,
1913 decode_key_lparam (msg->lParam)));
1915 ignore_wm_char = TRUE;
1919 event->key.window = window;
1920 switch (msg->wParam)
1923 event->key.keyval = GDK_Pointer_Button1; break;
1925 event->key.keyval = GDK_Pointer_Button3; break;
1927 event->key.keyval = GDK_Pointer_Button2; break;
1929 event->key.keyval = GDK_Cancel; break;
1931 event->key.keyval = GDK_BackSpace; break;
1933 event->key.keyval = (GetKeyState(VK_SHIFT) < 0 ?
1934 GDK_ISO_Left_Tab : GDK_Tab);
1937 event->key.keyval = GDK_Clear; break;
1939 event->key.keyval = GDK_Return; break;
1941 /* Don't let Shift auto-repeat */
1942 if (msg->message == WM_KEYDOWN
1943 && (HIWORD (msg->lParam) & KF_REPEAT))
1944 ignore_wm_char = FALSE;
1946 event->key.keyval = GDK_Shift_L;
1949 /* And not Control either */
1950 if (msg->message == WM_KEYDOWN
1951 && (HIWORD (msg->lParam) & KF_REPEAT))
1952 ignore_wm_char = FALSE;
1953 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1954 event->key.keyval = GDK_Control_R;
1956 event->key.keyval = GDK_Control_L;
1960 if (msg->message == WM_KEYDOWN
1961 && (HIWORD (msg->lParam) & KF_REPEAT))
1962 ignore_wm_char = FALSE;
1963 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1965 /* AltGr key comes in as Control+Right Alt */
1966 if (GetKeyState (VK_CONTROL) < 0)
1968 ignore_wm_char = FALSE;
1969 is_altgr_key = TRUE;
1971 event->key.keyval = GDK_Alt_R;
1975 event->key.keyval = GDK_Alt_L;
1976 /* This needed in case she types Alt+nnn (on the numpad) */
1977 ignore_wm_char = FALSE;
1981 event->key.keyval = GDK_Pause; break;
1983 event->key.keyval = GDK_Caps_Lock; break;
1985 event->key.keyval = GDK_Escape; break;
1987 event->key.keyval = GDK_Prior; break;
1989 event->key.keyval = GDK_Next; break;
1991 event->key.keyval = GDK_End; break;
1993 event->key.keyval = GDK_Home; break;
1995 event->key.keyval = GDK_Left; break;
1997 event->key.keyval = GDK_Up; break;
1999 event->key.keyval = GDK_Right; break;
2001 event->key.keyval = GDK_Down; break;
2003 event->key.keyval = GDK_Select; break;
2005 event->key.keyval = GDK_Print; break;
2007 event->key.keyval = GDK_Execute; break;
2009 event->key.keyval = GDK_Insert; break;
2011 event->key.keyval = GDK_Delete; break;
2013 event->key.keyval = GDK_Help; break;
2024 /* Apparently applications work better if we just pass numpad digits
2025 * on as real digits? So wait for the WM_CHAR instead.
2027 ignore_wm_char = FALSE;
2030 event->key.keyval = GDK_KP_Multiply; break;
2032 /* Pass it on as an ASCII plus in WM_CHAR. */
2033 ignore_wm_char = FALSE;
2036 event->key.keyval = GDK_KP_Separator; break;
2038 /* Pass it on as an ASCII minus in WM_CHAR. */
2039 ignore_wm_char = FALSE;
2042 /* The keypad decimal key should also be passed on as the decimal
2043 * sign ('.' or ',' depending on the Windows locale settings,
2044 * apparently). So wait for the WM_CHAR here, also.
2046 ignore_wm_char = FALSE;
2049 event->key.keyval = GDK_KP_Divide; break;
2051 event->key.keyval = GDK_F1; break;
2053 event->key.keyval = GDK_F2; break;
2055 event->key.keyval = GDK_F3; break;
2057 event->key.keyval = GDK_F4; break;
2059 event->key.keyval = GDK_F5; break;
2061 event->key.keyval = GDK_F6; break;
2063 event->key.keyval = GDK_F7; break;
2065 event->key.keyval = GDK_F8; break;
2067 event->key.keyval = GDK_F9; break;
2069 event->key.keyval = GDK_F10; break;
2071 event->key.keyval = GDK_F11; break;
2073 event->key.keyval = GDK_F12; break;
2075 event->key.keyval = GDK_F13; break;
2077 event->key.keyval = GDK_F14; break;
2079 event->key.keyval = GDK_F15; break;
2081 event->key.keyval = GDK_F16; break;
2092 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2093 || GetKeyState (VK_MENU) < 0))
2094 /* Control- or Alt-digits won't come in as a WM_CHAR,
2095 * but beware of AltGr-digits, which are used for instance
2096 * on Finnish keyboards.
2098 event->key.keyval = GDK_0 + (msg->wParam - '0');
2100 ignore_wm_char = FALSE;
2102 case VK_OEM_PLUS: /* On my Win98, the '+' key comes in
2103 * as VK_OEM_PLUS, etc.
2112 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2113 || GetKeyState (VK_MENU) < 0))
2114 /* Control- or Alt-plus won't come in as WM_CHAR,
2115 * but beware of AltGr-plus which is backslash on
2118 /* All these VK_OEM keycodes happen to be the corresponding ASCII
2121 event->key.keyval = msg->wParam - 0x90;
2123 ignore_wm_char = FALSE;
2126 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2127 || GetKeyState (VK_MENU) < 0))
2128 /* ;: on US keyboard */
2129 event->key.keyval = ';';
2131 ignore_wm_char = FALSE;
2134 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2135 || GetKeyState (VK_MENU) < 0))
2136 /* `~ on US keyboard */
2137 event->key.keyval = '`';
2139 ignore_wm_char = FALSE;
2142 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
2143 || GetKeyState (VK_MENU) < 0))
2144 /* '" on US keyboard */
2145 event->key.keyval = '\'';
2147 ignore_wm_char = FALSE;
2150 if (msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSKEYUP)
2151 event->key.keyval = msg->wParam;
2153 ignore_wm_char = FALSE;
2157 if (!ignore_wm_char)
2160 if (!propagate (&window, msg,
2161 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2164 ASSIGN_WINDOW (window);
2166 is_altgr_key = FALSE;
2167 event->key.type = ((msg->message == WM_KEYDOWN
2168 || msg->message == WM_SYSKEYDOWN) ?
2169 GDK_KEY_PRESS : GDK_KEY_RELEASE);
2170 event->key.time = msg->time;
2171 event->key.state = 0;
2172 if (GetKeyState (VK_SHIFT) < 0)
2173 event->key.state |= GDK_SHIFT_MASK;
2174 if (GetKeyState (VK_CAPITAL) & 0x1)
2175 event->key.state |= GDK_LOCK_MASK;
2176 if (GetKeyState (VK_CONTROL) < 0)
2177 event->key.state |= GDK_CONTROL_MASK;
2178 if (msg->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
2179 event->key.state |= GDK_MOD1_MASK;
2180 event->key.string = NULL;
2181 event->key.length = 0;
2182 return_val = !GDK_WINDOW_DESTROYED (window);
2185 case WM_IME_COMPOSITION:
2186 if (!use_ime_composition)
2189 GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %#lx %#lx\n",
2190 (gulong) msg->hwnd, msg->lParam));
2191 if (msg->lParam & GCS_RESULTSTR)
2197 g_print ("WM_IME_CHAR: %#lx bytes: %#.04x\n",
2198 (gulong) msg->hwnd, msg->wParam));
2204 g_print ("WM_%sCHAR: %#lx %#x %s %s\n",
2205 (msg->message == WM_CHAR ? "" : "SYS"),
2206 (gulong) msg->hwnd, msg->wParam,
2207 decode_key_lparam (msg->lParam),
2208 (ignore_wm_char ? "ignored" : "")));
2212 ignore_wm_char = FALSE;
2217 if (!propagate (&window, msg,
2218 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2221 ASSIGN_WINDOW (window);
2223 event->key.window = window;
2224 return_val = !GDK_WINDOW_DESTROYED (window);
2226 if (return_val && (event->key.window == k_grab_window
2227 || (window_impl->event_mask & GDK_KEY_RELEASE_MASK)))
2229 if (window == k_grab_window
2230 || (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2232 /* Append a GDK_KEY_PRESS event to the pushback list
2233 * (from which it will be fetched before the release
2236 GdkEvent *event2 = gdk_event_new ();
2237 build_keypress_event (window_impl, event2, msg);
2238 event2->key.window = window;
2239 gdk_drawable_ref (window);
2240 gdk_event_queue_append (event2);
2241 GDK_NOTE (EVENTS, print_event (event2));
2243 /* Return the key release event. */
2244 build_keyrelease_event (window_impl, event, msg);
2247 && (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2249 /* Return just the key press event. */
2250 build_keypress_event (window_impl, event, msg);
2255 #if 0 /* Don't reset is_AltGr_key here. Othewise we can't type several
2256 * AltGr-accessed chars while keeping the AltGr pressed down
2259 is_AltGr_key = FALSE;
2263 case WM_LBUTTONDOWN:
2266 case WM_MBUTTONDOWN:
2269 case WM_RBUTTONDOWN:
2274 g_print ("WM_%cBUTTONDOWN: %#lx (%d,%d)\n",
2277 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2279 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2280 && gdk_input_ignore_core)
2282 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2286 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2288 if (window != current_window)
2289 synthesize_crossing_events (window, msg);
2291 event->button.type = GDK_BUTTON_PRESS;
2292 if (!propagate (&window, msg,
2293 p_grab_window, p_grab_owner_events, p_grab_mask,
2294 doesnt_want_button_press))
2296 ASSIGN_WINDOW (window);
2298 event->button.window = window;
2300 /* Emulate X11's automatic active grab */
2303 /* No explicit active grab, let's start one automatically */
2304 gint owner_events = window_impl->event_mask
2305 & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
2307 GDK_NOTE (EVENTS, g_print ("...automatic grab started\n"));
2308 gdk_pointer_grab (window,
2310 window_impl->event_mask,
2312 p_grab_automatic = TRUE;
2315 event->button.time = msg->time;
2316 if (window != orig_window)
2317 translate_mouse_coords (orig_window, window, msg);
2318 event->button.x = current_x = (gint16) LOWORD (msg->lParam);
2319 event->button.y = current_y = (gint16) HIWORD (msg->lParam);
2320 event->button.x_root = msg->pt.x;
2321 event->button.y_root = msg->pt.y;
2322 event->button.axes = NULL;
2323 event->button.state = build_pointer_event_state (msg);
2324 event->button.button = button;
2325 event->button.device = gdk_core_pointer;
2327 gdk_event_button_generate (event);
2329 return_val = !GDK_WINDOW_DESTROYED (window);
2343 g_print ("WM_%cBUTTONUP: %#lx (%d,%d)\n",
2346 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2348 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2350 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2351 && gdk_input_ignore_core)
2353 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2357 if (window != current_window)
2358 synthesize_crossing_events (window, msg);
2360 event->button.type = GDK_BUTTON_RELEASE;
2361 if (!propagate (&window, msg,
2362 p_grab_window, p_grab_owner_events, p_grab_mask,
2363 doesnt_want_button_release))
2365 ASSIGN_WINDOW (window);
2367 event->button.window = window;
2368 event->button.time = msg->time;
2369 if (window != orig_window)
2370 translate_mouse_coords (orig_window, window, msg);
2371 event->button.x = (gint16) LOWORD (msg->lParam);
2372 event->button.y = (gint16) HIWORD (msg->lParam);
2373 event->button.x_root = msg->pt.x;
2374 event->button.y_root = msg->pt.y;
2375 event->button.axes = NULL;
2376 event->button.state = build_pointer_event_state (msg);
2377 event->button.button = button;
2378 event->button.device = gdk_core_pointer;
2380 return_val = !GDK_WINDOW_DESTROYED (window);
2383 if (p_grab_window != NULL
2385 && (event->button.state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) == 0)
2386 gdk_pointer_ungrab (0);
2391 g_print ("WM_MOUSEMOVE: %#lx %#x (%d,%d)\n",
2392 (gulong) msg->hwnd, msg->wParam,
2393 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2395 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2397 /* If we haven't moved, don't create any event.
2398 * Windows sends WM_MOUSEMOVE messages after button presses
2399 * even if the mouse doesn't move. This disturbs gtk.
2401 if (window == current_window
2402 && LOWORD (msg->lParam) == current_x
2403 && HIWORD (msg->lParam) == current_y)
2406 /* HB: only process mouse move messages if we own the active window. */
2407 GetWindowThreadProcessId(GetActiveWindow(), &pidActWin);
2408 GetWindowThreadProcessId(msg->hwnd, &pidThis);
2409 if (pidActWin != pidThis)
2412 if (window != current_window)
2413 synthesize_crossing_events (window, msg);
2415 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2416 && gdk_input_ignore_core)
2418 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2422 event->motion.type = GDK_MOTION_NOTIFY;
2423 if (!propagate (&window, msg,
2424 p_grab_window, p_grab_owner_events, p_grab_mask,
2425 doesnt_want_button_motion))
2427 ASSIGN_WINDOW (window);
2429 event->motion.window = window;
2430 event->motion.time = msg->time;
2431 if (window != orig_window)
2432 translate_mouse_coords (orig_window, window, msg);
2433 event->motion.x = current_x = (gint16) LOWORD (msg->lParam);
2434 event->motion.y = current_y = (gint16) HIWORD (msg->lParam);
2435 event->motion.x_root = current_x_root = msg->pt.x;
2436 event->motion.y_root = current_y_root = msg->pt.y;
2437 event->motion.axes = NULL;
2438 event->motion.state = build_pointer_event_state (msg);
2439 event->motion.is_hint = FALSE;
2440 event->motion.device = gdk_core_pointer;
2442 return_val = !GDK_WINDOW_DESTROYED (window);
2445 case WM_NCMOUSEMOVE:
2447 g_print ("WM_NCMOUSEMOVE: %#lx x,y: %d %d\n",
2449 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2450 if (track_mouse_event == NULL
2451 && current_window != NULL
2452 && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2454 GDK_NOTE (EVENTS, g_print ("...synthesizing LEAVE_NOTIFY event\n"));
2456 event->crossing.type = GDK_LEAVE_NOTIFY;
2457 event->crossing.window = current_window;
2458 event->crossing.subwindow = NULL;
2459 event->crossing.time = msg->time;
2460 event->crossing.x = current_x;
2461 event->crossing.y = current_y;
2462 event->crossing.x_root = current_x_root;
2463 event->crossing.y_root = current_y_root;
2464 event->crossing.mode = GDK_CROSSING_NORMAL;
2465 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2467 event->crossing.focus = TRUE; /* ??? */
2468 event->crossing.state = 0; /* ??? */
2474 gdk_drawable_unref (current_window);
2475 current_window = NULL;
2481 GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %#lx %d\n",
2482 (gulong) msg->hwnd, HIWORD (msg->wParam)));
2484 event->scroll.type = GDK_SCROLL;
2486 /* WM_MOUSEWHEEL is delivered to the focus window Work around
2487 * that. Also, the position is in screen coordinates, not client
2488 * coordinates as with the button messages. I love the
2489 * consistency of Windows.
2491 pt.x = LOWORD (msg->lParam);
2492 pt.y = HIWORD (msg->lParam);
2493 if ((hwnd = WindowFromPoint (pt)) == NULL)
2497 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2500 if (new_window != window)
2502 gdk_drawable_unref (window);
2503 ASSIGN_WINDOW (new_window);
2504 gdk_drawable_ref (window);
2507 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2508 && gdk_input_ignore_core)
2510 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2514 if (!propagate (&window, msg,
2515 p_grab_window, p_grab_owner_events, p_grab_mask,
2516 doesnt_want_scroll))
2519 ASSIGN_WINDOW (window);
2521 ScreenToClient (msg->hwnd, &pt);
2522 event->button.window = window;
2523 event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2524 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2525 event->scroll.window = window;
2526 event->scroll.time = msg->time;
2527 event->scroll.x = (gint16) pt.x;
2528 event->scroll.y = (gint16) pt.y;
2529 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
2530 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
2531 event->scroll.state = build_pointer_event_state (msg);
2532 event->scroll.device = gdk_core_pointer;
2533 return_val = !GDK_WINDOW_DESTROYED (window);
2537 #ifdef USE_TRACKMOUSEEVENT
2539 GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %#lx\n", (gulong) msg->hwnd));
2541 if (!(window_impl->event_mask & GDK_LEAVE_NOTIFY_MASK))
2544 event->crossing.type = GDK_LEAVE_NOTIFY;
2545 event->crossing.window = window;
2546 event->crossing.subwindow = NULL;
2547 event->crossing.time = msg->time;
2548 event->crossing.x = current_x;
2549 event->crossing.y = current_y;
2550 event->crossing.x_root = current_xroot;
2551 event->crossing.y_root = current_yroot;
2552 event->crossing.mode = GDK_CROSSING_NORMAL;
2554 && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
2555 event->crossing.detail = GDK_NOTIFY_INFERIOR;
2556 else if (current_window
2557 && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
2558 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
2560 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2562 event->crossing.focus = TRUE; /* ??? */
2563 event->crossing.state = 0; /* ??? */
2567 gdk_drawable_unref (current_window);
2568 current_window = NULL;
2571 return_val = !GDK_WINDOW_DESTROYED (window);
2577 GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %#lx\n",
2578 (msg->message == WM_SETFOCUS ?
2580 (gulong) msg->hwnd));
2582 if (!(window_impl->event_mask & GDK_FOCUS_CHANGE_MASK))
2585 event->focus_change.type = GDK_FOCUS_CHANGE;
2586 event->focus_change.window = window;
2587 event->focus_change.in = (msg->message == WM_SETFOCUS);
2588 return_val = !GDK_WINDOW_DESTROYED (window);
2592 GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#lx dc %#x\n",
2593 (gulong) msg->hwnd, msg->wParam));
2595 if (GDK_WINDOW_DESTROYED (window))
2598 colormap_private = GDK_COLORMAP_PRIVATE_DATA (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap);
2599 hdc = (HDC) msg->wParam;
2600 if (colormap_private && colormap_private->xcolormap->rc_palette)
2604 if (SelectPalette (hdc, colormap_private->xcolormap->palette,
2606 WIN32_GDI_FAILED ("SelectPalette");
2607 if ((k = RealizePalette (hdc)) == GDI_ERROR)
2608 WIN32_GDI_FAILED ("RealizePalette");
2610 g_print ("WM_ERASEBKGND: selected %#x, realized %d colors\n",
2611 colormap_private->xcolormap->palette, k);
2614 *ret_val_flagp = TRUE;
2617 if (GDK_WINDOW_OBJECT (window)->input_only)
2620 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2622 /* If this window should have the same background as the
2623 * parent, fetch the parent. (And if the same goes for
2624 * the parent, fetch the grandparent, etc.)
2626 while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2628 gdk_drawable_unref (window);
2629 ASSIGN_WINDOW (GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent));
2630 gdk_drawable_ref (window);
2634 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
2636 bg = gdk_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
2637 GDK_WINDOW_OBJECT (window)->bg_color.pixel);
2639 GetClipBox (hdc, &rect);
2641 g_print ("...%ldx%ld@+%ld+%ld BG_PIXEL %.06lx\n",
2642 rect.right - rect.left,
2643 rect.bottom - rect.top,
2644 rect.left, rect.top,
2646 hbr = CreateSolidBrush (bg);
2648 g_print ("...CreateSolidBrush (%.08x) = %.08x\n", bg, hbr);
2650 if (!FillRect (hdc, &rect, hbr))
2651 WIN32_GDI_FAILED ("FillRect");
2654 else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
2655 GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
2657 pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
2658 pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (pixmap);
2659 GetClipBox (hdc, &rect);
2661 if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
2663 GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
2664 hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap));
2665 if (!FillRect (hdc, &rect, hbr))
2666 WIN32_GDI_FAILED ("FillRect");
2672 g_print ("...blitting pixmap %#lx (%dx%d) "
2673 "all over the place,\n"
2674 "...clip box = %ldx%ld@+%ld+%ld\n",
2675 (gulong) GDK_PIXMAP_HBITMAP (pixmap),
2676 pixmap_impl->width, pixmap_impl->height,
2677 rect.right - rect.left, rect.bottom - rect.top,
2678 rect.left, rect.top));
2680 if (!(bgdc = CreateCompatibleDC (hdc)))
2682 WIN32_GDI_FAILED ("CreateCompatibleDC");
2685 if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
2687 WIN32_GDI_FAILED ("SelectObject");
2692 while (i < rect.right)
2695 while (j < rect.bottom)
2697 if (i + pixmap_impl->width >= rect.left
2698 && j + pixmap_impl->height >= rect.top)
2700 if (!BitBlt (hdc, i, j,
2701 pixmap_impl->width, pixmap_impl->height,
2702 bgdc, 0, 0, SRCCOPY))
2704 WIN32_GDI_FAILED ("BitBlt");
2708 j += pixmap_impl->height;
2710 i += pixmap_impl->width;
2713 SelectObject (bgdc, oldbitmap);
2719 GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
2720 hbr = GetStockObject (BLACK_BRUSH);
2721 GetClipBox (hdc, &rect);
2722 if (!FillRect (hdc, &rect, hbr))
2723 WIN32_GDI_FAILED ("FillRect");
2728 if (!GetUpdateRect(msg->hwnd, NULL, FALSE))
2730 GDK_NOTE (EVENTS, g_print ("WM_PAINT: %#lx no update rect\n",
2731 (gulong) msg->hwnd));
2735 /* HB: don't generate GDK_EXPOSE events for InputOnly
2736 * windows -> backing store now works!
2738 if (GDK_WINDOW_OBJECT (window)->input_only)
2741 hdc = BeginPaint (msg->hwnd, &paintstruct);
2744 g_print ("WM_PAINT: %#lx %ldx%ld@+%ld+%ld %s dc %#lx\n",
2746 paintstruct.rcPaint.right - paintstruct.rcPaint.left,
2747 paintstruct.rcPaint.bottom - paintstruct.rcPaint.top,
2748 paintstruct.rcPaint.left, paintstruct.rcPaint.top,
2749 (paintstruct.fErase ? "erase" : ""),
2752 EndPaint (msg->hwnd, &paintstruct);
2754 if (!(window_impl->event_mask & GDK_EXPOSURE_MASK))
2757 if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left)
2758 || (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
2761 event->expose.type = GDK_EXPOSE;
2762 event->expose.window = window;
2763 event->expose.area.x = paintstruct.rcPaint.left;
2764 event->expose.area.y = paintstruct.rcPaint.top;
2765 event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2766 event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2767 event->expose.count = 0;
2769 return_val = !GDK_WINDOW_DESTROYED (window);
2772 GList *list = gdk_queued_events;
2773 while (list != NULL )
2775 if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
2776 (((GdkEvent *)list->data)->any.window == window) &&
2777 !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
2778 ((GdkEvent *)list->data)->expose.count++;
2786 GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %#lx %#x %#x\n",
2788 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2790 if (LOWORD (msg->lParam) != HTCLIENT)
2793 if (p_grab_window != NULL && p_grab_cursor != NULL)
2794 hcursor = p_grab_cursor;
2795 else if (!GDK_WINDOW_DESTROYED (window))
2796 hcursor = window_impl->hcursor;
2800 if (hcursor != NULL)
2802 GDK_NOTE (EVENTS, g_print ("...SetCursor(%#lx)\n", (gulong) hcursor));
2803 SetCursor (hcursor);
2804 *ret_val_flagp = TRUE;
2810 GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %#lx %d\n",
2814 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2817 event->any.type = (msg->wParam ? GDK_MAP : GDK_UNMAP);
2818 event->any.window = window;
2820 if (event->any.type == GDK_UNMAP
2821 && p_grab_window == window)
2822 gdk_pointer_ungrab (msg->time);
2824 if (event->any.type == GDK_UNMAP
2825 && k_grab_window == window)
2826 gdk_keyboard_ungrab (msg->time);
2828 return_val = !GDK_WINDOW_DESTROYED (window);
2833 g_print ("WM_SIZE: %#lx %s %dx%d\n",
2835 (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
2836 (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
2837 (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
2838 (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
2839 (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
2840 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2842 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2845 if (msg->wParam == SIZE_MINIMIZED)
2847 event->any.type = GDK_UNMAP;
2848 event->any.window = window;
2850 if (p_grab_window == window)
2851 gdk_pointer_ungrab (msg->time);
2853 if (k_grab_window == window)
2854 gdk_keyboard_ungrab (msg->time);
2856 return_val = !GDK_WINDOW_DESTROYED (window);
2858 else if ((msg->wParam == SIZE_RESTORED
2859 || msg->wParam == SIZE_MAXIMIZED)
2861 && GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2865 if (LOWORD (msg->lParam) == 0)
2868 event->configure.type = GDK_CONFIGURE;
2869 event->configure.window = window;
2872 ClientToScreen (msg->hwnd, &pt);
2873 event->configure.x = pt.x;
2874 event->configure.y = pt.y;
2875 event->configure.width = LOWORD (msg->lParam);
2876 event->configure.height = HIWORD (msg->lParam);
2877 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2878 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2879 window_impl->width = event->configure.width;
2880 window_impl->height = event->configure.height;
2882 if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
2883 GDK_WINDOW_OBJECT (window)->resize_count -= 1;
2885 return_val = !GDK_WINDOW_DESTROYED (window);
2887 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
2888 _gdk_input_configure_event (&event->configure, window);
2892 case WM_GETMINMAXINFO:
2893 GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %#lx\n", (gulong) msg->hwnd));
2895 mmi = (MINMAXINFO*) msg->lParam;
2896 if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
2898 mmi->ptMinTrackSize.x = window_impl->hint_min_width;
2899 mmi->ptMinTrackSize.y = window_impl->hint_min_height;
2901 if (window_impl->hint_flags & GDK_HINT_MAX_SIZE)
2903 mmi->ptMaxTrackSize.x = window_impl->hint_max_width;
2904 mmi->ptMaxTrackSize.y = window_impl->hint_max_height;
2906 mmi->ptMaxSize.x = window_impl->hint_max_width;
2907 mmi->ptMaxSize.y = window_impl->hint_max_height;
2912 GDK_NOTE (EVENTS, g_print ("WM_MOVE: %#lx (%d,%d)\n",
2914 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2916 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2919 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2920 && !IsIconic(msg->hwnd)
2921 && IsWindowVisible(msg->hwnd))
2923 event->configure.type = GDK_CONFIGURE;
2924 event->configure.window = window;
2925 event->configure.x = LOWORD (msg->lParam);
2926 event->configure.y = HIWORD (msg->lParam);
2927 GetClientRect (msg->hwnd, &rect);
2928 event->configure.width = rect.right;
2929 event->configure.height = rect.bottom;
2930 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2931 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2932 window_impl->width = event->configure.width;
2933 window_impl->height = event->configure.height;
2935 return_val = !GDK_WINDOW_DESTROYED (window);
2940 GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %#lx\n", (gulong) msg->hwnd));
2942 event->any.type = GDK_DELETE;
2943 event->any.window = window;
2945 return_val = !GDK_WINDOW_DESTROYED (window);
2949 /* No, don't use delayed rendering after all. It works only if the
2950 * delayed SetClipboardData is called from the WindowProc, it
2951 * seems. (The #else part below is test code for that. It succeeds
2952 * in setting the clipboard data. But if I call SetClipboardData
2953 * in gdk_property_change (as a consequence of the
2954 * GDK_SELECTION_REQUEST event), it fails. I deduce that this is
2955 * because delayed rendering requires that SetClipboardData is
2956 * called in the window procedure.)
2958 case WM_RENDERFORMAT:
2959 case WM_RENDERALLFORMATS:
2961 GDK_NOTE (EVENTS, flag = TRUE);
2963 g_print ("WM_%s: %#lx %#x (%s)\n",
2964 (msg->message == WM_RENDERFORMAT ? "RENDERFORMAT" :
2965 "RENDERALLFORMATS"),
2968 (msg->wParam == CF_TEXT ? "CF_TEXT" :
2969 (msg->wParam == CF_DIB ? "CF_DIB" :
2970 (msg->wParam == CF_UNICODETEXT ? "CF_UNICODETEXT" :
2971 (GetClipboardFormatName (msg->wParam, buf, sizeof (buf)), buf)))));
2974 event->selection.type = GDK_SELECTION_REQUEST;
2975 event->selection.window = window;
2976 event->selection.selection = gdk_clipboard_atom;
2977 if (msg->wParam == CF_TEXT)
2978 event->selection.target = GDK_TARGET_STRING;
2981 GetClipboardFormatName (msg->wParam, buf, sizeof (buf));
2982 event->selection.target = gdk_atom_intern (buf, FALSE);
2984 event->selection.property = gdk_selection_property;
2985 event->selection.requestor = (guint32) msg->hwnd;
2986 event->selection.time = msg->time;
2987 return_val = !GDK_WINDOW_DESTROYED (window);
2989 /* Test code, to see if SetClipboardData works when called from
2990 * the window procedure.
2993 HGLOBAL hdata = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, 10);
2994 char *ptr = GlobalLock (hdata);
2995 strcpy (ptr, "Huhhaa");
2996 GlobalUnlock (hdata);
2997 if (!SetClipboardData (CF_TEXT, hdata))
2998 WIN32_API_FAILED ("SetClipboardData");
3001 *ret_val_flagp = TRUE;
3005 #endif /* No delayed rendering */
3008 GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %#lx\n", (gulong) msg->hwnd));
3010 event->any.type = GDK_DESTROY;
3011 event->any.window = window;
3012 if (window != NULL && window == current_window)
3014 gdk_drawable_unref (current_window);
3015 current_window = NULL;
3018 if (p_grab_window == window)
3019 gdk_pointer_ungrab (msg->time);
3021 if (k_grab_window == window)
3022 gdk_keyboard_ungrab (msg->time);
3024 return_val = window != NULL && !GDK_WINDOW_DESTROYED (window);
3026 if ((window != NULL) && (gdk_root_window != msg->hwnd))
3027 gdk_window_destroy_notify (window);
3032 /* Handle WINTAB events here, as we know that gdkinput.c will
3033 * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
3034 * constants as case labels.
3037 GDK_NOTE (EVENTS, g_print ("WT_PACKET: %#lx %d %#lx\n",
3039 msg->wParam, msg->lParam));
3043 GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %#lx %d %#lx\n",
3045 msg->wParam, msg->lParam));
3049 GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %#lx %#x %d %d\n",
3050 (gulong) msg->hwnd, msg->wParam,
3051 LOWORD (msg->lParam),
3052 HIWORD (msg->lParam)));
3055 event->any.window = window;
3056 return_val = _gdk_input_other_event(event, msg, window);
3061 GDK_NOTE (EVENTS, g_print ("%s: %#lx %#x %#lx\n",
3062 gdk_win32_message_name (msg->message),
3064 msg->wParam, msg->lParam));
3071 if (event->any.window)
3072 gdk_drawable_ref (event->any.window);
3073 if (((event->any.type == GDK_ENTER_NOTIFY) ||
3074 (event->any.type == GDK_LEAVE_NOTIFY)) &&
3075 (event->crossing.subwindow != NULL))
3076 gdk_drawable_ref (event->crossing.subwindow);
3078 GDK_NOTE (EVENTS, print_event (event));
3082 /* Mark this event as having no resources to be freed */
3083 event->any.window = NULL;
3084 event->any.type = GDK_NOTHING;
3088 gdk_drawable_unref (window);
3094 gdk_events_queue (void)
3098 while (!gdk_event_queue_find_first ()
3099 && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3101 GDK_NOTE (EVENTS, g_print ("PeekMessage: %#lx %s\n",
3102 (gulong) msg.hwnd, gdk_win32_message_name (msg.message)));
3104 if (active_imm_msgpump_owner == NULL
3105 || (active_imm_msgpump_owner->lpVtbl->OnTranslateMessage) (active_imm_msgpump_owner, &msg) != S_OK)
3106 TranslateMessage (&msg);
3108 DispatchMessage (&msg);
3113 gdk_event_prepare (GSource *source,
3119 GDK_THREADS_ENTER ();
3123 retval = (gdk_event_queue_find_first () != NULL)
3124 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3126 GDK_THREADS_LEAVE ();
3132 gdk_event_check (GSource *source)
3137 GDK_THREADS_ENTER ();
3139 if (event_poll_fd.revents & G_IO_IN)
3140 retval = (gdk_event_queue_find_first () != NULL)
3141 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3145 GDK_THREADS_LEAVE ();
3151 gdk_event_dispatch (GSource *source,
3152 GSourceFunc callback,
3157 GDK_THREADS_ENTER ();
3160 event = gdk_event_unqueue();
3165 (*gdk_event_func) (event, gdk_event_data);
3167 gdk_event_free (event);
3170 GDK_THREADS_LEAVE ();
3175 /* Sends a ClientMessage to all toplevel client windows */
3177 gdk_event_send_client_message (GdkEvent *event, guint32 xid)
3184 gdk_event_send_clientmessage_toall (GdkEvent *event)
3195 #ifdef G_ENABLE_DEBUG
3198 gdk_win32_message_name (UINT msg)
3200 static gchar bfr[100];
3204 #define CASE(x) case x: return #x
3212 CASE (WM_KILLFOCUS);
3214 CASE (WM_SETREDRAW);
3217 CASE (WM_GETTEXTLENGTH);
3220 CASE (WM_QUERYENDSESSION);
3221 CASE (WM_QUERYOPEN);
3222 CASE (WM_ENDSESSION);
3224 CASE (WM_ERASEBKGND);
3225 CASE (WM_SYSCOLORCHANGE);
3226 CASE (WM_SHOWWINDOW);
3227 CASE (WM_WININICHANGE);
3228 CASE (WM_DEVMODECHANGE);
3229 CASE (WM_ACTIVATEAPP);
3230 CASE (WM_FONTCHANGE);
3231 CASE (WM_TIMECHANGE);
3232 CASE (WM_CANCELMODE);
3233 CASE (WM_SETCURSOR);
3234 CASE (WM_MOUSEACTIVATE);
3235 CASE (WM_CHILDACTIVATE);
3236 CASE (WM_QUEUESYNC);
3237 CASE (WM_GETMINMAXINFO);
3238 CASE (WM_PAINTICON);
3239 CASE (WM_ICONERASEBKGND);
3240 CASE (WM_NEXTDLGCTL);
3241 CASE (WM_SPOOLERSTATUS);
3243 CASE (WM_MEASUREITEM);
3244 CASE (WM_DELETEITEM);
3245 CASE (WM_VKEYTOITEM);
3246 CASE (WM_CHARTOITEM);
3249 CASE (WM_SETHOTKEY);
3250 CASE (WM_GETHOTKEY);
3251 CASE (WM_QUERYDRAGICON);
3252 CASE (WM_COMPAREITEM);
3253 CASE (WM_GETOBJECT);
3254 CASE (WM_COMPACTING);
3255 CASE (WM_WINDOWPOSCHANGING);
3256 CASE (WM_WINDOWPOSCHANGED);
3259 CASE (WM_CANCELJOURNAL);
3261 CASE (WM_INPUTLANGCHANGEREQUEST);
3262 CASE (WM_INPUTLANGCHANGE);
3265 CASE (WM_USERCHANGED);
3266 CASE (WM_NOTIFYFORMAT);
3267 CASE (WM_CONTEXTMENU);
3268 CASE (WM_STYLECHANGING);
3269 CASE (WM_STYLECHANGED);
3270 CASE (WM_DISPLAYCHANGE);
3274 CASE (WM_NCDESTROY);
3275 CASE (WM_NCCALCSIZE);
3276 CASE (WM_NCHITTEST);
3278 CASE (WM_NCACTIVATE);
3279 CASE (WM_GETDLGCODE);
3280 CASE (WM_SYNCPAINT);
3281 CASE (WM_NCMOUSEMOVE);
3282 CASE (WM_NCLBUTTONDOWN);
3283 CASE (WM_NCLBUTTONUP);
3284 CASE (WM_NCLBUTTONDBLCLK);
3285 CASE (WM_NCRBUTTONDOWN);
3286 CASE (WM_NCRBUTTONUP);
3287 CASE (WM_NCRBUTTONDBLCLK);
3288 CASE (WM_NCMBUTTONDOWN);
3289 CASE (WM_NCMBUTTONUP);
3290 CASE (WM_NCMBUTTONDBLCLK);
3291 CASE (WM_NCXBUTTONDOWN);
3292 CASE (WM_NCXBUTTONUP);
3293 CASE (WM_NCXBUTTONDBLCLK);
3298 CASE (WM_SYSKEYDOWN);
3301 CASE (WM_SYSDEADCHAR);
3303 CASE (WM_IME_STARTCOMPOSITION);
3304 CASE (WM_IME_ENDCOMPOSITION);
3305 CASE (WM_IME_COMPOSITION);
3306 CASE (WM_INITDIALOG);
3308 CASE (WM_SYSCOMMAND);
3313 CASE (WM_INITMENUPOPUP);
3314 CASE (WM_MENUSELECT);
3316 CASE (WM_ENTERIDLE);
3317 CASE (WM_MENURBUTTONUP);
3319 CASE (WM_MENUGETOBJECT);
3320 CASE (WM_UNINITMENUPOPUP);
3321 CASE (WM_MENUCOMMAND);
3322 CASE (WM_CHANGEUISTATE);
3323 CASE (WM_UPDATEUISTATE);
3324 CASE (WM_QUERYUISTATE);
3325 CASE (WM_CTLCOLORMSGBOX);
3326 CASE (WM_CTLCOLOREDIT);
3327 CASE (WM_CTLCOLORLISTBOX);
3328 CASE (WM_CTLCOLORBTN);
3329 CASE (WM_CTLCOLORDLG);
3330 CASE (WM_CTLCOLORSCROLLBAR);
3331 CASE (WM_CTLCOLORSTATIC);
3332 CASE (WM_MOUSEMOVE);
3333 CASE (WM_LBUTTONDOWN);
3334 CASE (WM_LBUTTONUP);
3335 CASE (WM_LBUTTONDBLCLK);
3336 CASE (WM_RBUTTONDOWN);
3337 CASE (WM_RBUTTONUP);
3338 CASE (WM_RBUTTONDBLCLK);
3339 CASE (WM_MBUTTONDOWN);
3340 CASE (WM_MBUTTONUP);
3341 CASE (WM_MBUTTONDBLCLK);
3342 CASE (WM_MOUSEWHEEL);
3343 CASE (WM_XBUTTONDOWN);
3344 CASE (WM_XBUTTONUP);
3345 CASE (WM_XBUTTONDBLCLK);
3346 CASE (WM_PARENTNOTIFY);
3347 CASE (WM_ENTERMENULOOP);
3348 CASE (WM_EXITMENULOOP);
3351 CASE (WM_CAPTURECHANGED);
3353 CASE (WM_POWERBROADCAST);
3354 CASE (WM_DEVICECHANGE);
3355 CASE (WM_MDICREATE);
3356 CASE (WM_MDIDESTROY);
3357 CASE (WM_MDIACTIVATE);
3358 CASE (WM_MDIRESTORE);
3360 CASE (WM_MDIMAXIMIZE);
3362 CASE (WM_MDICASCADE);
3363 CASE (WM_MDIICONARRANGE);
3364 CASE (WM_MDIGETACTIVE);
3365 CASE (WM_MDISETMENU);
3366 CASE (WM_ENTERSIZEMOVE);
3367 CASE (WM_EXITSIZEMOVE);
3368 CASE (WM_DROPFILES);
3369 CASE (WM_MDIREFRESHMENU);
3370 CASE (WM_IME_SETCONTEXT);
3371 CASE (WM_IME_NOTIFY);
3372 CASE (WM_IME_CONTROL);
3373 CASE (WM_IME_COMPOSITIONFULL);
3374 CASE (WM_IME_SELECT);
3376 CASE (WM_IME_REQUEST);
3377 CASE (WM_IME_KEYDOWN);
3378 CASE (WM_IME_KEYUP);
3379 CASE (WM_MOUSEHOVER);
3380 CASE (WM_MOUSELEAVE);
3381 CASE (WM_NCMOUSEHOVER);
3382 CASE (WM_NCMOUSELEAVE);
3388 CASE (WM_RENDERFORMAT);
3389 CASE (WM_RENDERALLFORMATS);
3390 CASE (WM_DESTROYCLIPBOARD);
3391 CASE (WM_DRAWCLIPBOARD);
3392 CASE (WM_PAINTCLIPBOARD);
3393 CASE (WM_VSCROLLCLIPBOARD);
3394 CASE (WM_SIZECLIPBOARD);
3395 CASE (WM_ASKCBFORMATNAME);
3396 CASE (WM_CHANGECBCHAIN);
3397 CASE (WM_HSCROLLCLIPBOARD);
3398 CASE (WM_QUERYNEWPALETTE);
3399 CASE (WM_PALETTEISCHANGING);
3400 CASE (WM_PALETTECHANGED);
3403 CASE (WM_PRINTCLIENT);
3404 CASE (WM_APPCOMMAND);
3405 CASE (WM_HANDHELDFIRST);
3406 CASE (WM_HANDHELDLAST);
3409 CASE (WM_PENWINFIRST);
3410 CASE (WM_PENWINLAST);
3414 if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST)
3415 sprintf (bfr, "WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST);
3416 else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST)
3417 sprintf (bfr, "WM_AFXFIRST+%d", msg - WM_AFXFIRST);
3418 else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST)
3419 sprintf (bfr, "WM_PENWINFIRST+%d", msg - WM_PENWINFIRST);
3420 else if (msg >= WM_USER && msg <= 0x7FFF)
3421 sprintf (bfr, "WM_USER+%d", msg - WM_USER);
3422 else if (msg >= 0xC000 && msg <= 0xFFFF)
3423 sprintf (bfr, "reg-%#x", msg);
3425 sprintf (bfr, "unk-%#x", msg);
3428 g_assert_not_reached ();
3431 #endif /* G_ENABLE_DEBUG */