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/.
28 /* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message
29 * doesn't tell us where the mouse has gone. Thus we cannot use it to
30 * generate a correct GdkNotifyType. Pity, as using TrackMouseEvent
31 * otherwise would make it possible to reliably generate
32 * GDK_LEAVE_NOTIFY events, which would help get rid of those pesky
33 * tooltips sometimes popping up in the wrong place.
35 /* define USE_TRACKMOUSEEVENT */
37 /* Do use SetCapture, it works now. Thanks to jpe@archaeopteryx.com */
38 #define USE_SETCAPTURE 1
43 #include "gdkprivate-win32.h"
44 #include "gdkinput-win32.h"
45 #include "gdkkeysyms.h"
49 #if defined (__GNUC__) && defined (HAVE_DIMM_H)
50 /* The w32api imm.h clashes a bit with the IE5.5 dimm.h */
51 # define IMEMENUITEMINFOA hidden_IMEMENUITEMINFOA
52 # define IMEMENUITEMINFOW hidden_IMEMENUITEMINFOW
57 #if defined (__GNUC__) && defined (HAVE_DIMM_H)
58 # undef IMEMENUITEMINFOA
59 # undef IMEMENUITEMINFOW
67 typedef struct _GdkEventPrivate GdkEventPrivate;
71 /* Following flag is set for events on the event queue during
72 * translation and cleared afterwards.
74 GDK_EVENT_PENDING = 1 << 0
77 struct _GdkEventPrivate
84 * Private function declarations
87 static GdkFilterReturn
88 gdk_event_apply_filters(MSG *msg,
91 static gboolean gdk_event_translate (GdkEvent *event,
93 gboolean *ret_val_flagp,
95 gboolean return_exposes);
97 static gboolean gdk_event_prepare (GSource *source,
99 static gboolean gdk_event_check (GSource *source);
100 static gboolean gdk_event_dispatch (GSource *source,
101 GSourceFunc callback,
104 /* Private variable declarations
107 static GdkWindow *p_grab_window = NULL; /* Window that currently
108 * holds the pointer grab
111 static GdkWindow *k_grab_window = NULL; /* Window the holds the
115 static GList *client_filters; /* Filters for client messages */
117 static gboolean p_grab_automatic;
118 static GdkEventMask p_grab_mask;
119 static gboolean p_grab_owner_events, k_grab_owner_events;
120 static HCURSOR p_grab_cursor;
122 static GSourceFuncs event_funcs = {
129 GPollFD event_poll_fd;
131 static GdkWindow *current_window = NULL;
132 static gint current_x, current_y;
133 static gdouble current_x_root, current_y_root;
134 static UINT gdk_ping_msg;
135 static UINT msh_mousewheel_msg;
136 static gboolean ignore_wm_char = FALSE;
137 static gboolean is_altgr_key = FALSE;
140 static IActiveIMMApp *active_imm_app = NULL;
141 static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
144 typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
145 static PFN_TrackMouseEvent track_mouse_event = NULL;
147 static gboolean use_ime_composition = FALSE;
150 real_window_procedure (HWND hwnd,
155 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, FALSE))
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);
264 return DefWindowProc (hwnd, message, wparam, lparam);
266 if (active_imm_app == NULL
267 || (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
268 return DefWindowProc (hwnd, message, wparam, lparam);
276 _gdk_win32_window_procedure (HWND hwnd,
283 GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %#lx %s\n",
284 (gulong) hwnd, gdk_win32_message_name (message)));
286 retval = real_window_procedure (hwnd, message, wparam, lparam);
288 GDK_NOTE (MISC, g_print ("_gdk_win32_window_procedure: %#lx returns %ld\n",
289 (gulong) hwnd, retval));
295 _gdk_events_init (void)
301 #ifdef USE_TRACKMOUSEEVENT
302 HMODULE user32, imm32;
303 HINSTANCE commctrl32;
306 gdk_ping_msg = RegisterWindowMessage ("gdk-ping");
307 GDK_NOTE (EVENTS, g_print ("gdk-ping = %#x\n", gdk_ping_msg));
309 /* This is the string MSH_MOUSEWHEEL from zmouse.h,
310 * http://www.microsoft.com/mouse/intellimouse/sdk/zmouse.h
311 * This message is used by mouse drivers than cannot generate WM_MOUSEWHEEL
314 msh_mousewheel_msg = RegisterWindowMessage ("MSWHEEL_ROLLMSG");
315 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL = %#x\n", msh_mousewheel_msg));
317 source = g_source_new (&event_funcs, sizeof (GSource));
318 g_source_set_priority (source, GDK_PRIORITY_EVENTS);
320 event_poll_fd.fd = G_WIN32_MSG_HANDLE;
321 event_poll_fd.events = G_IO_IN;
323 g_source_add_poll (source, &event_poll_fd);
324 g_source_set_can_recurse (source, TRUE);
325 g_source_attach (source, NULL);
328 hres = CoCreateInstance (&CLSID_CActiveIMM,
332 (LPVOID *) &active_imm_app);
336 GDK_NOTE (EVENTS, g_print ("IActiveIMMApp created %p\n",
338 (*active_imm_app->lpVtbl->Activate) (active_imm_app, TRUE);
340 hres = (*active_imm_app->lpVtbl->QueryInterface) (active_imm_app, &IID_IActiveIMMMessagePumpOwner, &active_imm_msgpump_owner);
341 GDK_NOTE (EVENTS, g_print ("IActiveIMMMessagePumpOwner created %p\n",
342 active_imm_msgpump_owner));
343 (active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
347 #ifdef USE_TRACKMOUSEEVENT
348 user32 = GetModuleHandle ("user32.dll");
349 if ((track_mouse_event = GetProcAddress (user32, "TrackMouseEvent")) == NULL)
351 if ((commctrl32 = LoadLibrary ("commctrl32.dll")) != NULL)
352 track_mouse_event = (PFN_TrackMouseEvent)
353 GetProcAddress (commctrl32, "_TrackMouseEvent");
355 if (track_mouse_event != NULL)
356 GDK_NOTE (EVENTS, g_print ("Using TrackMouseEvent to detect leave events\n"));
358 if (IS_WIN_NT () && (windows_version & 0xFF) == 5)
360 /* On Win2k (Beta 3, at least) WM_IME_CHAR doesn't seem to work
361 * correctly for non-Unicode applications. Handle
362 * WM_IME_COMPOSITION with GCS_RESULTSTR instead, fetch the
363 * Unicode char from the IME with ImmGetCompositionStringW().
365 use_ime_composition = TRUE;
370 *--------------------------------------------------------------
373 * Returns if events are pending on the queue.
378 * Returns TRUE if events are pending
382 *--------------------------------------------------------------
386 gdk_events_pending (void)
390 return (_gdk_event_queue_find_first() ||
391 PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
395 *--------------------------------------------------------------
396 * gdk_event_get_graphics_expose
398 * Waits for a GraphicsExpose or NoExpose event
403 * For GraphicsExpose events, returns a pointer to the event
404 * converted into a GdkEvent Otherwise, returns NULL.
408 *-------------------------------------------------------------- */
411 gdk_event_get_graphics_expose (GdkWindow *window)
416 g_return_val_if_fail (window != NULL, NULL);
418 GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));
421 /* Some nasty bugs here, just return NULL for now. */
424 if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
426 event = _gdk_event_new ();
428 if (gdk_event_translate (event, &msg, NULL, NULL, TRUE))
431 gdk_event_free (event);
439 event_mask_string (GdkEventMask mask)
441 static char bfr[500];
446 if (mask & GDK_##x##_MASK) \
447 p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
450 BIT(POINTER_MOTION_HINT);
463 BIT(PROPERTY_CHANGE);
464 BIT(VISIBILITY_NOTIFY);
475 *--------------------------------------------------------------
478 * Grabs the pointer to a specific window
481 * "window" is the window which will receive the grab
482 * "owner_events" specifies whether events will be reported as is,
483 * or relative to "window"
484 * "event_mask" masks only interesting events
485 * "confine_to" limits the cursor movement to the specified window
486 * "cursor" changes the cursor for the duration of the grab
487 * "time" specifies the time
492 * requires a corresponding call to gdk_pointer_ungrab
494 *--------------------------------------------------------------
498 gdk_pointer_grab (GdkWindow *window,
499 gboolean owner_events,
500 GdkEventMask event_mask,
501 GdkWindow *confine_to,
505 HWND hwnd_confined_to;
507 GdkCursorPrivate *cursor_private;
510 g_return_val_if_fail (window != NULL, 0);
511 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
512 g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
514 cursor_private = (GdkCursorPrivate*) cursor;
516 if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
517 hwnd_confined_to = NULL;
519 hwnd_confined_to = GDK_WINDOW_HWND (confine_to);
524 hcursor = cursor_private->hcursor;
526 return_val = _gdk_input_grab_pointer (window,
532 if (return_val == GDK_GRAB_SUCCESS)
534 if (!GDK_WINDOW_DESTROYED (window))
536 GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#lx %s %#lx %s\n",
537 (gulong) GDK_WINDOW_HWND (window),
538 (owner_events ? "TRUE" : "FALSE"),
540 event_mask_string (event_mask)));
541 p_grab_mask = event_mask;
542 p_grab_owner_events = (owner_events != 0);
543 p_grab_automatic = FALSE;
546 SetCapture (GDK_WINDOW_HWND (window));
548 return_val = GDK_GRAB_SUCCESS;
551 return_val = GDK_GRAB_ALREADY_GRABBED;
554 if (return_val == GDK_GRAB_SUCCESS)
556 p_grab_window = window;
557 p_grab_cursor = hcursor;
564 *--------------------------------------------------------------
567 * Releases any pointer grab
575 *--------------------------------------------------------------
579 gdk_pointer_ungrab (guint32 time)
581 GDK_NOTE (EVENTS, g_print ("gdk_pointer_ungrab\n"));
583 _gdk_input_ungrab_pointer (time);
586 if (GetCapture () != NULL)
590 p_grab_window = NULL;
594 *--------------------------------------------------------------
595 * find_window_for_pointer_event
597 * Find the window a pointer event (mouse up, down, move) should
598 * be reported to. If the return value != reported_window then
599 * the ref count of reported_window will be decremented and the
600 * ref count of the return value will be incremented.
604 * "reported_window" is the gdk window the xevent was reported relative to
605 * "xevent" is the win32 message
611 *--------------------------------------------------------------
615 find_window_for_pointer_event (GdkWindow* reported_window,
621 GdkWindow* other_window;
623 if (p_grab_window == NULL || !p_grab_owner_events)
624 return reported_window;
626 points = MAKEPOINTS (msg->lParam);
629 ClientToScreen (msg->hwnd, &pt);
631 GDK_NOTE (EVENTS, g_print ("Finding window for grabbed pointer event at (%ld, %ld)\n",
634 hwnd = WindowFromPoint (pt);
636 return reported_window;
637 other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
638 if (other_window == NULL)
639 return reported_window;
641 GDK_NOTE (EVENTS, g_print ("Found window %#x for point (%ld, %ld)\n",
642 (guint) hwnd, pt.x, pt.y));
644 gdk_window_unref (reported_window);
645 gdk_window_ref (other_window);
651 *--------------------------------------------------------------
652 * gdk_pointer_is_grabbed
654 * Tell wether there is an active x pointer grab in effect
662 *--------------------------------------------------------------
666 gdk_pointer_is_grabbed (void)
668 return p_grab_window != NULL;
672 *--------------------------------------------------------------
675 * Grabs the keyboard to a specific window
678 * "window" is the window which will receive the grab
679 * "owner_events" specifies whether events will be reported as is,
680 * or relative to "window"
681 * "time" specifies the time
686 * requires a corresponding call to gdk_keyboard_ungrab
688 *--------------------------------------------------------------
692 gdk_keyboard_grab (GdkWindow *window,
693 gboolean owner_events,
698 g_return_val_if_fail (window != NULL, 0);
699 g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
701 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#lx\n",
702 (gulong) GDK_WINDOW_HWND (window)));
704 if (!GDK_WINDOW_DESTROYED (window))
706 k_grab_owner_events = owner_events != 0;
707 return_val = GDK_GRAB_SUCCESS;
710 return_val = GDK_GRAB_ALREADY_GRABBED;
712 if (return_val == GDK_GRAB_SUCCESS)
713 k_grab_window = window;
719 *--------------------------------------------------------------
720 * gdk_keyboard_ungrab
722 * Releases any keyboard grab
730 *--------------------------------------------------------------
734 gdk_keyboard_ungrab (guint32 time)
736 GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));
738 k_grab_window = NULL;
741 static GdkFilterReturn
742 gdk_event_apply_filters (MSG *msg,
746 GdkEventFilter *filter;
748 GdkFilterReturn result;
754 filter = (GdkEventFilter *) tmp_list->data;
756 result = (*filter->function) (msg, event, filter->data);
757 if (result != GDK_FILTER_CONTINUE)
760 tmp_list = tmp_list->next;
763 return GDK_FILTER_CONTINUE;
767 gdk_add_client_message_filter (GdkAtom message_type,
771 GdkClientFilter *filter = g_new (GdkClientFilter, 1);
773 filter->type = message_type;
774 filter->function = func;
777 client_filters = g_list_prepend (client_filters, filter);
780 /* Thanks to Markus G. Kuhn <mkuhn@acm.org> for the ksysym<->Unicode
781 * mapping functions, from the xterm sources.
785 build_key_event_state (GdkEvent *event)
787 if (GetKeyState (VK_SHIFT) < 0)
788 event->key.state |= GDK_SHIFT_MASK;
789 if (GetKeyState (VK_CAPITAL) & 0x1)
790 event->key.state |= GDK_LOCK_MASK;
793 if (GetKeyState (VK_CONTROL) < 0)
795 event->key.state |= GDK_CONTROL_MASK;
797 if (event->key.keyval < ' ')
798 event->key.keyval += '@';
802 else if (event->key.keyval < ' ')
804 event->key.state |= GDK_CONTROL_MASK;
805 event->key.keyval += '@';
808 if (GetKeyState (VK_MENU) < 0)
809 event->key.state |= GDK_MOD1_MASK;
814 build_pointer_event_state (MSG *msg)
819 if (msg->wParam & MK_CONTROL)
820 state |= GDK_CONTROL_MASK;
821 if (msg->wParam & MK_LBUTTON)
822 state |= GDK_BUTTON1_MASK;
823 if (msg->wParam & MK_MBUTTON)
824 state |= GDK_BUTTON2_MASK;
825 if (msg->wParam & MK_RBUTTON)
826 state |= GDK_BUTTON3_MASK;
827 if (msg->wParam & MK_SHIFT)
828 state |= GDK_SHIFT_MASK;
829 if (GetKeyState (VK_MENU) < 0)
830 state |= GDK_MOD1_MASK;
831 if (GetKeyState (VK_CAPITAL) & 0x1)
832 state |= GDK_LOCK_MASK;
838 build_keypress_event (GdkWindowImplWin32 *impl,
843 gint i, bytecount, ucount;
847 event->key.type = GDK_KEY_PRESS;
848 event->key.time = msg->time;
849 event->key.state = 0;
851 if (msg->message == WM_IME_COMPOSITION)
853 himc = ImmGetContext (msg->hwnd);
855 bytecount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
856 wbuf, sizeof (wbuf));
857 ucount = bytecount / 2;
861 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
863 bytecount = MIN ((msg->lParam & 0xFFFF), sizeof (buf));
864 for (i = 0; i < bytecount; i++)
865 buf[i] = msg->wParam;
867 else /* WM_IME_CHAR */
869 event->key.keyval = GDK_VoidSymbol;
870 if (msg->wParam & 0xFF00)
872 /* Contrary to some versions of the documentation,
873 * the lead byte is the most significant byte.
875 buf[0] = ((msg->wParam >> 8) & 0xFF);
876 buf[1] = (msg->wParam & 0xFF);
881 buf[0] = (msg->wParam & 0xFF);
886 /* Convert from the window's current code page
887 * to Unicode. Then convert to UTF-8.
888 * We don't handle the surrogate stuff. Should we?
890 ucount = MultiByteToWideChar (impl->charset_info.ciACP,
892 wbuf, G_N_ELEMENTS (wbuf));
895 event->key.keyval = GDK_VoidSymbol;
896 else if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
898 if (msg->wParam < ' ')
900 event->key.keyval = msg->wParam + '@';
901 /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
904 event->key.state |= GDK_CONTROL_MASK;
907 event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
910 build_key_event_state (event);
912 /* Build UTF-8 string */
913 if (ucount == 1 && wbuf[0] < 0200)
915 event->key.string = g_malloc (2);
916 event->key.string[0] = wbuf[0];
917 event->key.string[1] = '\0';
918 event->key.length = 1;
922 event->key.string = _gdk_ucs2_to_utf8 (wbuf, ucount);
923 event->key.length = strlen (event->key.string);
928 build_keyrelease_event (GdkWindowImplWin32 *impl,
935 event->key.type = GDK_KEY_RELEASE;
936 event->key.time = msg->time;
937 event->key.state = 0;
939 if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
940 if (msg->wParam < ' ')
941 event->key.keyval = msg->wParam + '@';
945 MultiByteToWideChar (impl->charset_info.ciACP,
946 0, &buf, 1, &wbuf, 1);
948 event->key.keyval = gdk_unicode_to_keyval (wbuf);
951 event->key.keyval = GDK_VoidSymbol;
952 build_key_event_state (event);
953 event->key.string = NULL;
954 event->key.length = 0;
958 print_event_state (gint state)
960 #define CASE(bit) if (state & GDK_ ## bit ## _MASK) g_print (#bit " ");
972 print_window_state (GdkWindowState state)
974 #define CASE(bit) if (state & GDK_WINDOW_STATE_ ## bit ) g_print (#bit " ");
983 print_event (GdkEvent *event)
985 gchar *escaped, *kvname;
987 switch (event->any.type)
989 #define CASE(x) case x: g_print ( #x " "); break;
994 CASE (GDK_MOTION_NOTIFY);
995 CASE (GDK_BUTTON_PRESS);
996 CASE (GDK_2BUTTON_PRESS);
997 CASE (GDK_3BUTTON_PRESS);
998 CASE (GDK_BUTTON_RELEASE);
999 CASE (GDK_KEY_PRESS);
1000 CASE (GDK_KEY_RELEASE);
1001 CASE (GDK_ENTER_NOTIFY);
1002 CASE (GDK_LEAVE_NOTIFY);
1003 CASE (GDK_FOCUS_CHANGE);
1004 CASE (GDK_CONFIGURE);
1007 CASE (GDK_PROPERTY_NOTIFY);
1008 CASE (GDK_SELECTION_CLEAR);
1009 CASE (GDK_SELECTION_REQUEST);
1010 CASE (GDK_SELECTION_NOTIFY);
1011 CASE (GDK_PROXIMITY_IN);
1012 CASE (GDK_PROXIMITY_OUT);
1013 CASE (GDK_DRAG_ENTER);
1014 CASE (GDK_DRAG_LEAVE);
1015 CASE (GDK_DRAG_MOTION);
1016 CASE (GDK_DRAG_STATUS);
1017 CASE (GDK_DROP_START);
1018 CASE (GDK_DROP_FINISHED);
1019 CASE (GDK_CLIENT_EVENT);
1020 CASE (GDK_VISIBILITY_NOTIFY);
1021 CASE (GDK_NO_EXPOSE);
1023 CASE (GDK_WINDOW_STATE);
1027 g_print ("%#lx ", (gulong) GDK_WINDOW_HWND (event->any.window));
1029 switch (event->any.type)
1032 g_print ("%dx%d@+%d+%d %d",
1033 event->expose.area.width,
1034 event->expose.area.height,
1035 event->expose.area.x,
1036 event->expose.area.y,
1037 event->expose.count);
1039 case GDK_MOTION_NOTIFY:
1040 g_print ("(%.4g,%.4g) %s",
1041 event->motion.x, event->motion.y,
1042 event->motion.is_hint ? "HINT " : "");
1043 print_event_state (event->motion.state);
1045 case GDK_BUTTON_PRESS:
1046 case GDK_2BUTTON_PRESS:
1047 case GDK_3BUTTON_PRESS:
1048 case GDK_BUTTON_RELEASE:
1049 g_print ("%d (%.4g,%.4g) ",
1050 event->button.button,
1051 event->button.x, event->button.y);
1052 print_event_state (event->button.state);
1055 case GDK_KEY_RELEASE:
1056 if (event->key.length == 0)
1057 escaped = g_strdup ("");
1059 escaped = g_strescape (event->key.string, NULL);
1060 kvname = gdk_keyval_name (event->key.keyval);
1061 g_print ("%s %d:\"%s\" ",
1062 (kvname ? kvname : "??"),
1066 print_event_state (event->key.state);
1068 case GDK_ENTER_NOTIFY:
1069 case GDK_LEAVE_NOTIFY:
1071 (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
1072 (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
1073 (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
1078 (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
1079 (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
1080 (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
1081 (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
1083 print_event_state (event->scroll.state);
1085 case GDK_WINDOW_STATE:
1086 print_window_state (event->window_state.changed_mask);
1087 print_window_state (event->window_state.new_window_state);
1096 gdk_window_is_child (GdkWindow *parent,
1099 if (parent == NULL || window == NULL)
1102 return (gdk_window_get_parent (window) == parent ||
1103 gdk_window_is_child (parent, gdk_window_get_parent (window)));
1107 synthesize_enter_or_leave_event (GdkWindow *window,
1110 GdkNotifyType detail,
1116 event = _gdk_event_new ();
1117 event->crossing.type = type;
1118 event->crossing.window = window;
1119 event->crossing.send_event = FALSE;
1120 gdk_window_ref (event->crossing.window);
1121 event->crossing.subwindow = NULL;
1122 event->crossing.time = msg->time;
1123 event->crossing.x = x;
1124 event->crossing.y = y;
1125 event->crossing.x_root = msg->pt.x;
1126 event->crossing.y_root = msg->pt.y;
1127 event->crossing.mode = GDK_CROSSING_NORMAL;
1128 event->crossing.detail = detail;
1129 event->crossing.focus = TRUE; /* ??? */
1130 event->crossing.state = 0; /* ??? */
1132 _gdk_event_queue_append (event);
1134 if (type == GDK_ENTER_NOTIFY
1135 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
1136 _gdk_input_enter_event (&event->crossing, window);
1138 GDK_NOTE (EVENTS, print_event (event));
1142 synthesize_leave_event (GdkWindow *window,
1144 GdkNotifyType detail)
1148 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1151 /* Leave events are at (current_x,current_y) in current_window */
1153 if (current_window != window)
1157 ClientToScreen (GDK_WINDOW_HWND (current_window), &pt);
1158 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1159 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, pt.x, pt.y);
1162 synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, detail, current_x, current_y);
1167 synthesize_enter_event (GdkWindow *window,
1169 GdkNotifyType detail)
1173 if (!(GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK))
1176 /* Enter events are at LOWORD (msg->lParam), HIWORD
1177 * (msg->lParam) in msg->hwnd */
1179 pt.x = LOWORD (msg->lParam);
1180 pt.y = HIWORD (msg->lParam);
1181 if (msg->hwnd != GDK_WINDOW_HWND (window))
1183 ClientToScreen (msg->hwnd, &pt);
1184 ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1186 synthesize_enter_or_leave_event (window, msg, GDK_ENTER_NOTIFY, detail, pt.x, pt.y);
1190 synthesize_enter_events (GdkWindow *from,
1193 GdkNotifyType detail)
1195 GdkWindow *prev = gdk_window_get_parent (to);
1198 synthesize_enter_events (from, prev, msg, detail);
1199 synthesize_enter_event (to, msg, detail);
1203 synthesize_leave_events (GdkWindow *from,
1206 GdkNotifyType detail)
1208 GdkWindow *next = gdk_window_get_parent (from);
1210 synthesize_leave_event (from, msg, detail);
1212 synthesize_leave_events (next, to, msg, detail);
1216 synthesize_crossing_events (GdkWindow *window,
1219 GdkWindow *intermediate, *tem, *common_ancestor;
1221 if (gdk_window_is_child (current_window, window))
1223 /* Pointer has moved to an inferior window. */
1224 synthesize_leave_event (current_window, msg, GDK_NOTIFY_INFERIOR);
1226 /* If there are intermediate windows, generate ENTER_NOTIFY
1229 intermediate = gdk_window_get_parent (window);
1230 if (intermediate != current_window)
1232 synthesize_enter_events (current_window, intermediate, msg, GDK_NOTIFY_VIRTUAL);
1235 synthesize_enter_event (window, msg, GDK_NOTIFY_ANCESTOR);
1237 else if (gdk_window_is_child (window, current_window))
1239 /* Pointer has moved to an ancestor window. */
1240 synthesize_leave_event (current_window, msg, GDK_NOTIFY_ANCESTOR);
1242 /* If there are intermediate windows, generate LEAVE_NOTIFY
1245 intermediate = gdk_window_get_parent (current_window);
1246 if (intermediate != window)
1248 synthesize_leave_events (intermediate, window, msg, GDK_NOTIFY_VIRTUAL);
1251 else if (current_window)
1253 /* Find least common ancestor of current_window and window */
1254 tem = current_window;
1256 common_ancestor = gdk_window_get_parent (tem);
1257 tem = common_ancestor;
1258 } while (common_ancestor &&
1259 !gdk_window_is_child (common_ancestor, window));
1260 if (common_ancestor)
1262 synthesize_leave_event (current_window, msg, GDK_NOTIFY_NONLINEAR);
1263 intermediate = gdk_window_get_parent (current_window);
1264 if (intermediate != common_ancestor)
1266 synthesize_leave_events (intermediate, common_ancestor,
1267 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1269 intermediate = gdk_window_get_parent (window);
1270 if (intermediate != common_ancestor)
1272 synthesize_enter_events (common_ancestor, intermediate,
1273 msg, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1275 synthesize_enter_event (window, msg, GDK_NOTIFY_NONLINEAR);
1280 /* Dunno where we are coming from */
1281 synthesize_enter_event (window, msg, GDK_NOTIFY_UNKNOWN);
1285 gdk_window_unref (current_window);
1286 current_window = window;
1287 gdk_window_ref (current_window);
1291 translate_mouse_coords (GdkWindow *window1,
1297 pt.x = LOWORD (msg->lParam);
1298 pt.y = HIWORD (msg->lParam);
1299 ClientToScreen (GDK_WINDOW_HWND (window1), &pt);
1300 ScreenToClient (GDK_WINDOW_HWND (window2), &pt);
1301 msg->lParam = MAKELPARAM (pt.x, pt.y);
1302 GDK_NOTE (EVENTS, g_print ("...new coords are (%ld,%ld)\n", pt.x, pt.y));
1306 propagate (GdkWindow **window,
1308 GdkWindow *grab_window,
1309 gboolean grab_owner_events,
1311 gboolean (*doesnt_want_it) (gint mask,
1314 gboolean in_propagation = FALSE;
1316 if (grab_window != NULL && !grab_owner_events)
1318 /* Event source is grabbed with owner_events FALSE */
1319 GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE, "));
1320 if ((*doesnt_want_it) (grab_mask, msg))
1322 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1327 GDK_NOTE (EVENTS, g_print ("...sending to grabber %#lx\n",
1328 (gulong) GDK_WINDOW_HWND (grab_window)));
1329 gdk_drawable_unref (*window);
1330 *window = grab_window;
1331 gdk_drawable_ref (*window);
1337 if ((*doesnt_want_it) (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (*window)->impl)->event_mask, msg))
1339 /* Owner doesn't want it, propagate to parent. */
1340 if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == _gdk_parent_root)
1342 /* No parent; check if grabbed */
1343 if (grab_window != NULL)
1345 /* Event source is grabbed with owner_events TRUE */
1346 GDK_NOTE (EVENTS, g_print ("...undelivered, but grabbed\n"));
1347 if ((*doesnt_want_it) (grab_mask, msg))
1349 /* Grabber doesn't want it either */
1350 GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1357 g_print ("...sending to grabber %#lx\n",
1358 (gulong) GDK_WINDOW_HWND (grab_window)));
1359 gdk_drawable_unref (*window);
1360 *window = grab_window;
1361 gdk_drawable_ref (*window);
1367 GDK_NOTE (EVENTS, g_print ("...undelivered\n"));
1373 gdk_drawable_unref (*window);
1374 *window = GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent);
1375 gdk_drawable_ref (*window);
1376 GDK_NOTE (EVENTS, g_print ("%s %#lx",
1377 (in_propagation ? "," : " ...propagating to"),
1378 (gulong) GDK_WINDOW_HWND (*window)));
1379 /* The only branch where we actually continue the loop */
1380 in_propagation = TRUE;
1389 doesnt_want_key (gint mask,
1392 return (((msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
1393 && !(mask & GDK_KEY_RELEASE_MASK))
1395 ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1396 && !(mask & GDK_KEY_PRESS_MASK)));
1400 doesnt_want_char (gint mask,
1403 return !(mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK));
1407 doesnt_want_button_press (gint mask,
1410 return !(mask & GDK_BUTTON_PRESS_MASK);
1414 doesnt_want_button_release (gint mask,
1417 return !(mask & GDK_BUTTON_RELEASE_MASK);
1421 doesnt_want_button_motion (gint mask,
1424 return !((mask & GDK_POINTER_MOTION_MASK)
1425 || ((msg->wParam & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))
1426 && (mask & GDK_BUTTON_MOTION_MASK))
1427 || ((msg->wParam & MK_LBUTTON)
1428 && (mask & GDK_BUTTON1_MOTION_MASK))
1429 || ((msg->wParam & MK_MBUTTON)
1430 && (mask & GDK_BUTTON2_MOTION_MASK))
1431 || ((msg->wParam & MK_RBUTTON)
1432 && (mask & GDK_BUTTON3_MOTION_MASK)));
1436 doesnt_want_scroll (gint mask,
1440 return !(mask & GDK_SCROLL_MASK);
1442 return !(mask & GDK_BUTTON_PRESS_MASK);
1447 decode_key_lparam (LPARAM lParam)
1449 static char buf[100];
1452 if (HIWORD (lParam) & KF_UP)
1453 p += sprintf (p, "KF_UP ");
1454 if (HIWORD (lParam) & KF_REPEAT)
1455 p += sprintf (p, "KF_REPEAT ");
1456 if (HIWORD (lParam) & KF_ALTDOWN)
1457 p += sprintf (p, "KF_ALTDOWN ");
1458 if (HIWORD (lParam) & KF_EXTENDED)
1459 p += sprintf (p, "KF_EXTENDED ");
1460 p += sprintf (p, "sc%d rep%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
1466 gdk_event_translate (GdkEvent *event,
1468 gboolean *ret_val_flagp,
1470 gboolean return_exposes)
1474 PAINTSTRUCT paintstruct;
1487 * window_impl == GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)
1490 GdkWindowImplWin32 *window_impl;
1491 #define ASSIGN_WINDOW(rhs) \
1493 window_impl = (window ? GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl) : NULL))
1495 GdkWindow *orig_window, *new_window;
1496 GdkColormap *colormap;
1497 GdkColormapPrivateWin32 *colormap_private;
1499 GdkPixmapImplWin32 *pixmap_impl;
1500 gint xoffset, yoffset;
1506 gboolean return_val;
1511 *ret_val_flagp = FALSE;
1513 ASSIGN_WINDOW (gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd));
1514 orig_window = window;
1516 event->any.window = window;
1518 /* InSendMessage() does not really mean the same as X11's send_event flag,
1519 * but it is close enough, says jpe@archaeopteryx.com.
1521 event->any.send_event = InSendMessage ();
1525 /* Handle WM_QUIT here ? */
1526 if (msg->message == WM_QUIT)
1528 GDK_NOTE (EVENTS, g_print ("WM_QUIT: %d\n", msg->wParam));
1531 else if (msg->message == WM_MOVE
1532 || msg->message == WM_SIZE)
1534 /* It's quite normal to get these messages before we have
1535 * had time to register the window in our lookup table, or
1536 * when the window is being destroyed and we already have
1537 * removed it. Repost the same message to our queue so that
1538 * we will get it later when we are prepared.
1540 GDK_NOTE(MISC, g_print("gdk_event_translate: %#lx %s posted.\n",
1542 msg->message == WM_MOVE ?
1543 "WM_MOVE" : "WM_SIZE"));
1545 PostMessage (msg->hwnd, msg->message,
1546 msg->wParam, msg->lParam);
1548 #ifndef WITHOUT_WM_CREATE
1549 else if (WM_CREATE == msg->message)
1551 window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
1552 GDK_WINDOW_HWND (window) = msg->hwnd;
1553 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: created %#x\n",
1554 (guint) msg->hwnd));
1556 /* This should handle allmost all the other window==NULL cases.
1557 * This code is executed while gdk_window_new is in it's
1558 * CreateWindowEx call.
1559 * Don't insert xid there a second time, if it's done here.
1561 gdk_drawable_ref (window);
1562 gdk_win32_handle_table_insert (&GDK_WINDOW_HWND(window), window);
1567 GDK_NOTE (EVENTS, g_print ("gdk_event_translate: %s for %#x (NULL)\n",
1568 gdk_win32_message_name(msg->message),
1569 (guint) msg->hwnd));
1575 gdk_drawable_ref (window);
1577 if (!GDK_WINDOW_DESTROYED (window))
1579 /* Check for filters for this window */
1580 GdkFilterReturn result;
1582 result = gdk_event_apply_filters
1583 (msg, event, GDK_WINDOW_OBJECT (window)->filters);
1585 if (result != GDK_FILTER_CONTINUE)
1587 return_val = (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1589 *ret_val_flagp = TRUE;
1591 *ret_valp = return_val;
1596 /* to translate coordinates to the internal > 16 bit system */
1597 _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
1599 if (msg->message == msh_mousewheel_msg)
1601 GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %#lx %d\n",
1602 (gulong) msg->hwnd, msg->wParam));
1604 event->scroll.type = GDK_SCROLL;
1606 /* MSG_MOUSEWHEEL is delivered to the foreground window. Work
1607 * around that. Also, the position is in screen coordinates, not
1608 * client coordinates as with the button messages.
1610 pt.x = LOWORD (msg->lParam);
1611 pt.y = HIWORD (msg->lParam);
1612 if ((hwnd = WindowFromPoint (pt)) == NULL)
1616 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
1619 if (new_window != window)
1621 gdk_drawable_unref (window);
1622 ASSIGN_WINDOW (new_window);
1623 gdk_drawable_ref (window);
1626 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
1627 && _gdk_input_ignore_core)
1629 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
1633 if (!propagate (&window, msg,
1634 p_grab_window, p_grab_owner_events, p_grab_mask,
1635 doesnt_want_scroll))
1638 ASSIGN_WINDOW (window);
1640 ScreenToClient (msg->hwnd, &pt);
1641 event->button.window = window;
1642 event->scroll.direction = ((int) msg->wParam > 0) ?
1643 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
1644 event->scroll.window = window;
1645 event->scroll.time = msg->time;
1646 event->scroll.x = (gint16) pt.x + xoffset;
1647 event->scroll.y = (gint16) pt.y + yoffset;
1648 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
1649 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
1650 event->scroll.state = 0; /* No state information with MSH_MOUSEWHEEL */
1651 event->scroll.device = _gdk_core_pointer;
1652 return_val = !GDK_WINDOW_DESTROYED (window);
1659 GdkFilterReturn result = GDK_FILTER_CONTINUE;
1661 tmp_list = client_filters;
1664 GdkClientFilter *filter = tmp_list->data;
1665 /* FIXME: under win32 messages are not really atoms
1666 * as the following cast suggest, but the appears to be right
1667 * Haven't found a use case though ...
1669 if (filter->type == GDK_POINTER_TO_ATOM (msg->message))
1671 GDK_NOTE (EVENTS, g_print ("client filter matched\n"));
1672 event->any.window = window;
1673 result = (*filter->function) (msg, event, filter->data);
1676 case GDK_FILTER_REMOVE:
1677 *ret_val_flagp = TRUE;
1682 case GDK_FILTER_TRANSLATE:
1686 case GDK_FILTER_CONTINUE:
1687 *ret_val_flagp = TRUE;
1690 event->client.type = GDK_CLIENT_EVENT;
1691 event->client.window = window;
1692 /* FIXME: check if the cast is correct, see above */
1693 event->client.message_type = GDK_POINTER_TO_ATOM (msg->message);
1694 event->client.data_format = 0;
1695 event->client.data.l[0] = msg->wParam;
1696 event->client.data.l[1] = msg->lParam;
1701 tmp_list = tmp_list->next;
1705 switch (msg->message)
1707 case WM_INPUTLANGCHANGE:
1709 g_print ("WM_INPUTLANGCHANGE: %#lx charset %lu locale %lx\n",
1710 (gulong) msg->hwnd, (gulong) msg->wParam, msg->lParam));
1711 window_impl->input_locale = (HKL) msg->lParam;
1712 TranslateCharsetInfo ((DWORD FAR *) msg->wParam,
1713 &window_impl->charset_info,
1720 g_print ("WM_SYSKEY%s: %#lx %s %#x %s\n",
1721 (msg->message == WM_SYSKEYUP ? "UP" : "DOWN"),
1723 (GetKeyNameText (msg->lParam, buf,
1727 decode_key_lparam (msg->lParam)));
1729 /* Let the system handle Alt-Tab and Alt-Enter */
1730 if (msg->wParam == VK_TAB
1731 || msg->wParam == VK_RETURN
1732 || msg->wParam == VK_F4)
1734 /* If posted without us having keyboard focus, ignore */
1735 if (!(msg->lParam & 0x20000000))
1738 /* don't generate events for just the Alt key */
1739 if (msg->wParam == VK_MENU)
1742 /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
1748 g_print ("WM_KEY%s: %#lx %s %#x %s\n",
1749 (msg->message == WM_KEYUP ? "UP" : "DOWN"),
1751 (GetKeyNameText (msg->lParam, buf,
1755 decode_key_lparam (msg->lParam)));
1757 ignore_wm_char = TRUE;
1761 event->key.window = window;
1762 event->key.hardware_keycode = msg->wParam;
1764 switch (msg->wParam)
1767 event->key.keyval = GDK_Pointer_Button1; break;
1769 event->key.keyval = GDK_Pointer_Button3; break;
1771 event->key.keyval = GDK_Pointer_Button2; break;
1773 event->key.keyval = GDK_Cancel; break;
1775 event->key.keyval = GDK_BackSpace; break;
1777 event->key.keyval = (GetKeyState(VK_SHIFT) < 0 ?
1778 GDK_ISO_Left_Tab : GDK_Tab);
1781 event->key.keyval = GDK_Clear; break;
1783 event->key.keyval = GDK_Return; break;
1785 /* Don't let Shift auto-repeat */
1786 if (msg->message == WM_KEYDOWN
1787 && (HIWORD (msg->lParam) & KF_REPEAT))
1788 ignore_wm_char = FALSE;
1790 event->key.keyval = GDK_Shift_L;
1793 /* And not Control either */
1794 if (msg->message == WM_KEYDOWN
1795 && (HIWORD (msg->lParam) & KF_REPEAT))
1796 ignore_wm_char = FALSE;
1797 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1798 event->key.keyval = GDK_Control_R;
1800 event->key.keyval = GDK_Control_L;
1804 if (msg->message == WM_KEYDOWN
1805 && (HIWORD (msg->lParam) & KF_REPEAT))
1806 ignore_wm_char = FALSE;
1807 else if (HIWORD (msg->lParam) & KF_EXTENDED)
1809 /* AltGr key comes in as Control+Right Alt */
1810 if (GetKeyState (VK_CONTROL) < 0)
1812 ignore_wm_char = FALSE;
1813 is_altgr_key = TRUE;
1815 event->key.keyval = GDK_Alt_R;
1819 event->key.keyval = GDK_Alt_L;
1820 /* This needed in case she types Alt+nnn (on the numpad) */
1821 ignore_wm_char = FALSE;
1825 event->key.keyval = GDK_Pause; break;
1827 event->key.keyval = GDK_Caps_Lock; break;
1829 event->key.keyval = GDK_Escape; break;
1831 event->key.keyval = GDK_Prior; break;
1833 event->key.keyval = GDK_Next; break;
1835 event->key.keyval = GDK_End; break;
1837 event->key.keyval = GDK_Home; break;
1839 event->key.keyval = GDK_Left; break;
1841 event->key.keyval = GDK_Up; break;
1843 event->key.keyval = GDK_Right; break;
1845 event->key.keyval = GDK_Down; break;
1847 event->key.keyval = GDK_Select; break;
1849 event->key.keyval = GDK_Print; break;
1851 event->key.keyval = GDK_Execute; break;
1853 event->key.keyval = GDK_Insert; break;
1855 event->key.keyval = GDK_Delete; break;
1857 event->key.keyval = GDK_Help; break;
1868 /* Apparently applications work better if we just pass numpad digits
1869 * on as real digits? So wait for the WM_CHAR instead.
1871 ignore_wm_char = FALSE;
1874 event->key.keyval = GDK_KP_Multiply; break;
1876 /* Pass it on as an ASCII plus in WM_CHAR. */
1877 ignore_wm_char = FALSE;
1880 event->key.keyval = GDK_KP_Separator; break;
1882 /* Pass it on as an ASCII minus in WM_CHAR. */
1883 ignore_wm_char = FALSE;
1886 /* The keypad decimal key should also be passed on as the decimal
1887 * sign ('.' or ',' depending on the Windows locale settings,
1888 * apparently). So wait for the WM_CHAR here, also.
1890 ignore_wm_char = FALSE;
1893 event->key.keyval = GDK_KP_Divide; break;
1895 event->key.keyval = GDK_F1; break;
1897 event->key.keyval = GDK_F2; break;
1899 event->key.keyval = GDK_F3; break;
1901 event->key.keyval = GDK_F4; break;
1903 event->key.keyval = GDK_F5; break;
1905 event->key.keyval = GDK_F6; break;
1907 event->key.keyval = GDK_F7; break;
1909 event->key.keyval = GDK_F8; break;
1911 event->key.keyval = GDK_F9; break;
1913 event->key.keyval = GDK_F10; break;
1915 event->key.keyval = GDK_F11; break;
1917 event->key.keyval = GDK_F12; break;
1919 event->key.keyval = GDK_F13; break;
1921 event->key.keyval = GDK_F14; break;
1923 event->key.keyval = GDK_F15; break;
1925 event->key.keyval = GDK_F16; break;
1936 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1937 || GetKeyState (VK_MENU) < 0))
1938 /* Control- or Alt-digits won't come in as a WM_CHAR,
1939 * but beware of AltGr-digits, which are used for instance
1940 * on Finnish keyboards.
1942 event->key.keyval = GDK_0 + (msg->wParam - '0');
1944 ignore_wm_char = FALSE;
1946 case VK_OEM_PLUS: /* On my Win98, the '+' key comes in
1947 * as VK_OEM_PLUS, etc.
1956 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1957 || GetKeyState (VK_MENU) < 0))
1958 /* Control- or Alt-plus won't come in as WM_CHAR,
1959 * but beware of AltGr-plus which is backslash on
1962 /* All these VK_OEM keycodes happen to be the corresponding ASCII
1965 event->key.keyval = msg->wParam - 0x90;
1967 ignore_wm_char = FALSE;
1970 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1971 || GetKeyState (VK_MENU) < 0))
1972 /* ;: on US keyboard */
1973 event->key.keyval = ';';
1975 ignore_wm_char = FALSE;
1978 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1979 || GetKeyState (VK_MENU) < 0))
1980 /* `~ on US keyboard */
1981 event->key.keyval = '`';
1983 ignore_wm_char = FALSE;
1986 if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1987 || GetKeyState (VK_MENU) < 0))
1988 /* '" on US keyboard */
1989 event->key.keyval = '\'';
1991 ignore_wm_char = FALSE;
1994 if (msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSKEYUP)
1995 event->key.keyval = msg->wParam;
1997 ignore_wm_char = FALSE;
2001 if (!ignore_wm_char)
2004 if (!propagate (&window, msg,
2005 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2008 ASSIGN_WINDOW (window);
2010 is_altgr_key = FALSE;
2011 event->key.type = ((msg->message == WM_KEYDOWN
2012 || msg->message == WM_SYSKEYDOWN) ?
2013 GDK_KEY_PRESS : GDK_KEY_RELEASE);
2014 event->key.time = msg->time;
2015 event->key.state = 0;
2016 if (GetKeyState (VK_SHIFT) < 0)
2017 event->key.state |= GDK_SHIFT_MASK;
2018 if (GetKeyState (VK_CAPITAL) & 0x1)
2019 event->key.state |= GDK_LOCK_MASK;
2020 if (GetKeyState (VK_CONTROL) < 0)
2021 event->key.state |= GDK_CONTROL_MASK;
2022 if (msg->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
2023 event->key.state |= GDK_MOD1_MASK;
2024 event->key.string = NULL;
2025 event->key.length = 0;
2026 return_val = !GDK_WINDOW_DESTROYED (window);
2029 case WM_IME_COMPOSITION:
2030 if (!use_ime_composition)
2033 GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %#lx %#lx\n",
2034 (gulong) msg->hwnd, msg->lParam));
2035 if (msg->lParam & GCS_RESULTSTR)
2041 g_print ("WM_IME_CHAR: %#lx bytes: %#.04x\n",
2042 (gulong) msg->hwnd, msg->wParam));
2048 g_print ("WM_%sCHAR: %#lx %#x %s %s\n",
2049 (msg->message == WM_CHAR ? "" : "SYS"),
2050 (gulong) msg->hwnd, msg->wParam,
2051 decode_key_lparam (msg->lParam),
2052 (ignore_wm_char ? "ignored" : "")));
2056 ignore_wm_char = FALSE;
2061 if (!propagate (&window, msg,
2062 k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2065 ASSIGN_WINDOW (window);
2067 event->key.window = window;
2068 return_val = !GDK_WINDOW_DESTROYED (window);
2070 if (return_val && (event->key.window == k_grab_window
2071 || (window_impl->event_mask & GDK_KEY_RELEASE_MASK)))
2073 if (window == k_grab_window
2074 || (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2076 /* Append a GDK_KEY_PRESS event to the pushback list
2077 * (from which it will be fetched before the release
2080 GdkEvent *event2 = _gdk_event_new ();
2081 build_keypress_event (window_impl, event2, msg);
2082 event2->key.window = window;
2083 gdk_drawable_ref (window);
2084 _gdk_event_queue_append (event2);
2085 GDK_NOTE (EVENTS, print_event (event2));
2087 /* Return the key release event. */
2088 build_keyrelease_event (window_impl, event, msg);
2091 && (window_impl->event_mask & GDK_KEY_PRESS_MASK))
2093 /* Return just the key press event. */
2094 build_keypress_event (window_impl, event, msg);
2099 #if 0 /* Don't reset is_AltGr_key here. Othewise we can't type several
2100 * AltGr-accessed chars while keeping the AltGr pressed down
2103 is_AltGr_key = FALSE;
2107 case WM_LBUTTONDOWN:
2110 case WM_MBUTTONDOWN:
2113 case WM_RBUTTONDOWN:
2118 g_print ("WM_%cBUTTONDOWN: %#lx (%d,%d)\n",
2121 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2123 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2124 && _gdk_input_ignore_core)
2126 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2130 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2132 if (window != current_window)
2133 synthesize_crossing_events (window, msg);
2135 event->button.type = GDK_BUTTON_PRESS;
2136 if (!propagate (&window, msg,
2137 p_grab_window, p_grab_owner_events, p_grab_mask,
2138 doesnt_want_button_press))
2140 ASSIGN_WINDOW (window);
2142 event->button.window = window;
2144 /* Emulate X11's automatic active grab */
2147 /* No explicit active grab, let's start one automatically */
2148 gint owner_events = window_impl->event_mask
2149 & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
2151 GDK_NOTE (EVENTS, g_print ("...automatic grab started\n"));
2152 gdk_pointer_grab (window,
2154 window_impl->event_mask,
2156 p_grab_automatic = TRUE;
2159 event->button.time = msg->time;
2160 if (window != orig_window)
2161 translate_mouse_coords (orig_window, window, msg);
2162 event->button.x = current_x = (gint16) LOWORD (msg->lParam);
2163 event->button.y = current_y = (gint16) HIWORD (msg->lParam);
2164 event->button.x += xoffset; /* XXX translate current_x, y too? */
2165 event->button.y += yoffset;
2166 event->button.x_root = msg->pt.x;
2167 event->button.y_root = msg->pt.y;
2168 event->button.axes = NULL;
2169 event->button.state = build_pointer_event_state (msg);
2170 event->button.button = button;
2171 event->button.device = _gdk_core_pointer;
2173 _gdk_event_button_generate (event);
2175 return_val = !GDK_WINDOW_DESTROYED (window);
2189 g_print ("WM_%cBUTTONUP: %#lx (%d,%d)\n",
2192 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2194 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2196 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2197 && _gdk_input_ignore_core)
2199 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2203 if (window != current_window)
2204 synthesize_crossing_events (window, msg);
2206 event->button.type = GDK_BUTTON_RELEASE;
2207 if (!propagate (&window, msg,
2208 p_grab_window, p_grab_owner_events, p_grab_mask,
2209 doesnt_want_button_release))
2214 ASSIGN_WINDOW (window);
2216 event->button.window = window;
2217 event->button.time = msg->time;
2218 if (window != orig_window)
2219 translate_mouse_coords (orig_window, window, msg);
2220 event->button.x = (gint16) LOWORD (msg->lParam) + xoffset;
2221 event->button.y = (gint16) HIWORD (msg->lParam) + yoffset;
2222 event->button.x_root = msg->pt.x;
2223 event->button.y_root = msg->pt.y;
2224 event->button.axes = NULL;
2225 event->button.state = build_pointer_event_state (msg);
2226 event->button.button = button;
2227 event->button.device = _gdk_core_pointer;
2229 return_val = !GDK_WINDOW_DESTROYED (window);
2232 if (p_grab_window != NULL
2234 && (msg->wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) == 0)
2235 gdk_pointer_ungrab (0);
2240 g_print ("WM_MOUSEMOVE: %#lx %#x (%d,%d)\n",
2241 (gulong) msg->hwnd, msg->wParam,
2242 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2244 ASSIGN_WINDOW (find_window_for_pointer_event (window, msg));
2246 /* If we haven't moved, don't create any event.
2247 * Windows sends WM_MOUSEMOVE messages after button presses
2248 * even if the mouse doesn't move. This disturbs gtk.
2250 if (window == current_window
2251 && LOWORD (msg->lParam) == current_x
2252 && HIWORD (msg->lParam) == current_y)
2255 /* HB: only process mouse move messages if we own the active window. */
2256 GetWindowThreadProcessId(GetActiveWindow(), &pidActWin);
2257 GetWindowThreadProcessId(msg->hwnd, &pidThis);
2258 if (pidActWin != pidThis)
2261 if (window != current_window)
2262 synthesize_crossing_events (window, msg);
2264 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2265 && _gdk_input_ignore_core)
2267 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2271 event->motion.type = GDK_MOTION_NOTIFY;
2272 if (!propagate (&window, msg,
2273 p_grab_window, p_grab_owner_events, p_grab_mask,
2274 doesnt_want_button_motion))
2276 ASSIGN_WINDOW (window);
2278 event->motion.window = window;
2279 event->motion.time = msg->time;
2280 if (window != orig_window)
2281 translate_mouse_coords (orig_window, window, msg);
2282 event->motion.x = current_x = (gint16) LOWORD (msg->lParam);
2283 event->motion.y = current_y = (gint16) HIWORD (msg->lParam);
2284 event->motion.x += xoffset;
2285 event->motion.y += yoffset;
2286 event->motion.x_root = current_x_root = msg->pt.x;
2287 event->motion.y_root = current_y_root = msg->pt.y;
2288 event->motion.axes = NULL;
2289 event->motion.state = build_pointer_event_state (msg);
2290 event->motion.is_hint = FALSE;
2291 event->motion.device = _gdk_core_pointer;
2293 return_val = !GDK_WINDOW_DESTROYED (window);
2296 case WM_NCMOUSEMOVE:
2298 g_print ("WM_NCMOUSEMOVE: %#lx x,y: %d %d\n",
2300 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2301 if (track_mouse_event == NULL
2302 && current_window != NULL
2303 && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2305 GDK_NOTE (EVENTS, g_print ("...synthesizing LEAVE_NOTIFY event\n"));
2307 event->crossing.type = GDK_LEAVE_NOTIFY;
2308 event->crossing.window = current_window;
2309 event->crossing.subwindow = NULL;
2310 event->crossing.time = msg->time;
2311 event->crossing.x = current_x + xoffset; /* XXX translated current_x */
2312 event->crossing.y = current_y + yoffset;
2313 event->crossing.x_root = current_x_root;
2314 event->crossing.y_root = current_y_root;
2315 event->crossing.mode = GDK_CROSSING_NORMAL;
2316 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2318 event->crossing.focus = TRUE; /* ??? */
2319 event->crossing.state = 0; /* ??? */
2325 gdk_drawable_unref (current_window);
2326 current_window = NULL;
2332 GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %#lx %d\n",
2333 (gulong) msg->hwnd, HIWORD (msg->wParam)));
2335 event->scroll.type = GDK_SCROLL;
2337 /* WM_MOUSEWHEEL is delivered to the focus window Work around
2338 * that. Also, the position is in screen coordinates, not client
2339 * coordinates as with the button messages. I love the
2340 * consistency of Windows.
2342 pt.x = LOWORD (msg->lParam);
2343 pt.y = HIWORD (msg->lParam);
2344 if ((hwnd = WindowFromPoint (pt)) == NULL)
2348 if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2351 if (new_window != window)
2353 gdk_drawable_unref (window);
2354 ASSIGN_WINDOW (new_window);
2355 gdk_drawable_ref (window);
2358 if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2359 && _gdk_input_ignore_core)
2361 GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2365 if (!propagate (&window, msg,
2366 p_grab_window, p_grab_owner_events, p_grab_mask,
2367 doesnt_want_scroll))
2370 ASSIGN_WINDOW (window);
2372 ScreenToClient (msg->hwnd, &pt);
2373 event->button.window = window;
2374 event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2375 GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2376 event->scroll.window = window;
2377 event->scroll.time = msg->time;
2378 event->scroll.x = (gint16) pt.x + xoffset;
2379 event->scroll.y = (gint16) pt.y + yoffset;
2380 event->scroll.x_root = (gint16) LOWORD (msg->lParam);
2381 event->scroll.y_root = (gint16) HIWORD (msg->lParam);
2382 event->scroll.state = build_pointer_event_state (msg);
2383 event->scroll.device = _gdk_core_pointer;
2384 return_val = !GDK_WINDOW_DESTROYED (window);
2388 #ifdef USE_TRACKMOUSEEVENT
2390 GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %#lx\n", (gulong) msg->hwnd));
2392 if (!(window_impl->event_mask & GDK_LEAVE_NOTIFY_MASK))
2395 event->crossing.type = GDK_LEAVE_NOTIFY;
2396 event->crossing.window = window;
2397 event->crossing.subwindow = NULL;
2398 event->crossing.time = msg->time;
2399 event->crossing.x = current_x + xoffset; /* XXX translated current_x */
2400 event->crossing.y = current_y + yoffset;
2401 event->crossing.x_root = current_xroot;
2402 event->crossing.y_root = current_yroot;
2403 event->crossing.mode = GDK_CROSSING_NORMAL;
2405 && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
2406 event->crossing.detail = GDK_NOTIFY_INFERIOR;
2407 else if (current_window
2408 && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
2409 event->crossing.detail = GDK_NOTIFY_ANCESTOR;
2411 event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2413 event->crossing.focus = TRUE; /* ??? */
2414 event->crossing.state = 0; /* ??? */
2418 gdk_drawable_unref (current_window);
2419 current_window = NULL;
2422 return_val = !GDK_WINDOW_DESTROYED (window);
2428 GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %#lx\n",
2429 (msg->message == WM_SETFOCUS ?
2431 (gulong) msg->hwnd));
2433 if (!(window_impl->event_mask & GDK_FOCUS_CHANGE_MASK))
2436 event->focus_change.type = GDK_FOCUS_CHANGE;
2437 event->focus_change.window = window;
2438 event->focus_change.in = (msg->message == WM_SETFOCUS);
2439 return_val = !GDK_WINDOW_DESTROYED (window);
2443 GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#lx dc %#x\n",
2444 (gulong) msg->hwnd, msg->wParam));
2446 if (GDK_WINDOW_DESTROYED (window))
2449 *ret_val_flagp = TRUE; /* always claim as handled */
2452 if (GDK_WINDOW_OBJECT (window)->input_only)
2455 if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg)
2457 /* improves scolling effect, e.g. main buttons of testgtk */
2458 *ret_val_flagp = TRUE;
2463 colormap = gdk_drawable_get_colormap (window);
2465 colormap_private = GDK_COLORMAP_PRIVATE_DATA (colormap);
2466 hdc = (HDC) msg->wParam;
2467 if (colormap && colormap_private->xcolormap->rc_palette)
2471 if (SelectPalette (hdc, colormap_private->xcolormap->palette,
2473 WIN32_GDI_FAILED ("SelectPalette");
2474 if ((k = RealizePalette (hdc)) == GDI_ERROR)
2475 WIN32_GDI_FAILED ("RealizePalette");
2477 g_print ("WM_ERASEBKGND: selected %#x, realized %d colors\n",
2478 colormap_private->xcolormap->palette, k);
2482 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2484 /* If this window should have the same background as the
2485 * parent, fetch the parent. (And if the same goes for
2486 * the parent, fetch the grandparent, etc.)
2488 while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2490 gdk_drawable_unref (window);
2491 ASSIGN_WINDOW (GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent));
2492 gdk_drawable_ref (window);
2496 if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->position_info.no_bg)
2498 /* improves scolling effect, e.g. main buttons of testgtk */
2499 *ret_val_flagp = TRUE;
2504 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
2506 bg = _gdk_win32_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
2507 GDK_WINDOW_OBJECT (window)->bg_color.pixel);
2509 GetClipBox (hdc, &rect);
2511 g_print ("...%ldx%ld@+%ld+%ld BG_PIXEL %.06lx\n",
2512 rect.right - rect.left,
2513 rect.bottom - rect.top,
2514 rect.left, rect.top,
2516 hbr = CreateSolidBrush (bg);
2518 g_print ("...CreateSolidBrush (%.08x) = %.08x\n", bg, hbr);
2520 if (!FillRect (hdc, &rect, hbr))
2521 WIN32_GDI_FAILED ("FillRect");
2524 else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
2525 GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
2527 pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
2528 pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl);
2529 GetClipBox (hdc, &rect);
2531 if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
2533 GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
2534 hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap));
2535 if (!FillRect (hdc, &rect, hbr))
2536 WIN32_GDI_FAILED ("FillRect");
2542 g_print ("...blitting pixmap %#lx (%dx%d) "
2543 "all over the place,\n"
2544 "...clip box = %ldx%ld@+%ld+%ld\n",
2545 (gulong) GDK_PIXMAP_HBITMAP (pixmap),
2546 pixmap_impl->width, pixmap_impl->height,
2547 rect.right - rect.left, rect.bottom - rect.top,
2548 rect.left, rect.top));
2550 if (!(bgdc = CreateCompatibleDC (hdc)))
2552 WIN32_GDI_FAILED ("CreateCompatibleDC");
2555 if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
2557 WIN32_GDI_FAILED ("SelectObject");
2562 while (i < rect.right)
2565 while (j < rect.bottom)
2567 if (i + pixmap_impl->width >= rect.left
2568 && j + pixmap_impl->height >= rect.top)
2570 if (!BitBlt (hdc, i, j,
2571 pixmap_impl->width, pixmap_impl->height,
2572 bgdc, 0, 0, SRCCOPY))
2574 WIN32_GDI_FAILED ("BitBlt");
2578 j += pixmap_impl->height;
2580 i += pixmap_impl->width;
2583 SelectObject (bgdc, oldbitmap);
2589 GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
2590 hbr = GetStockObject (BLACK_BRUSH);
2591 GetClipBox (hdc, &rect);
2592 if (!FillRect (hdc, &rect, hbr))
2593 WIN32_GDI_FAILED ("FillRect");
2598 if (!GetUpdateRect(msg->hwnd, NULL, FALSE))
2600 GDK_NOTE (EVENTS, g_print ("WM_PAINT: %#lx no update rect\n",
2601 (gulong) msg->hwnd));
2605 hdc = BeginPaint (msg->hwnd, &paintstruct);
2608 g_print ("WM_PAINT: %#lx %ldx%ld@+%ld+%ld %s dc %#lx\n",
2610 paintstruct.rcPaint.right - paintstruct.rcPaint.left,
2611 paintstruct.rcPaint.bottom - paintstruct.rcPaint.top,
2612 paintstruct.rcPaint.left, paintstruct.rcPaint.top,
2613 (paintstruct.fErase ? "erase" : ""),
2616 EndPaint (msg->hwnd, &paintstruct);
2618 /* HB: don't generate GDK_EXPOSE events for InputOnly
2619 * windows -> backing store now works!
2621 if (GDK_WINDOW_OBJECT (window)->input_only)
2624 if (!(window_impl->event_mask & GDK_EXPOSURE_MASK))
2627 if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_NO_BG)
2630 if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left)
2631 || (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
2636 event->expose.type = GDK_EXPOSE;
2637 event->expose.window = window;
2638 event->expose.area.x = paintstruct.rcPaint.left;
2639 event->expose.area.y = paintstruct.rcPaint.top;
2640 event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2641 event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2642 event->expose.region = gdk_region_rectangle (&(event->expose.area));
2643 event->expose.count = 0;
2645 return_val = !GDK_WINDOW_DESTROYED (window);
2648 GList *list = _gdk_queued_events;
2649 while (list != NULL )
2651 if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
2652 (((GdkEvent *)list->data)->any.window == window) &&
2653 !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
2654 ((GdkEvent *)list->data)->expose.count++;
2662 GdkRectangle expose_rect;
2664 expose_rect.x = paintstruct.rcPaint.left + xoffset;
2665 expose_rect.y = paintstruct.rcPaint.top + yoffset;
2666 expose_rect.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2667 expose_rect.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2669 _gdk_window_process_expose (window, msg->time, &expose_rect);
2676 GDK_NOTE (EVENTS, g_print ("WM_GETICON: %#lx %s\n",
2678 (ICON_BIG == msg->wParam ? "big" : "small")));
2682 GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %#lx %#x %#x\n",
2684 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2686 if (LOWORD (msg->lParam) != HTCLIENT)
2689 if (p_grab_window != NULL && p_grab_cursor != NULL)
2690 hcursor = p_grab_cursor;
2691 else if (!GDK_WINDOW_DESTROYED (window))
2692 hcursor = window_impl->hcursor;
2696 if (hcursor != NULL)
2698 GDK_NOTE (EVENTS, g_print ("...SetCursor(%#lx)\n", (gulong) hcursor));
2699 SetCursor (hcursor);
2700 *ret_val_flagp = TRUE;
2706 GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %#lx %d\n",
2710 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2713 event->any.type = (msg->wParam ? GDK_MAP : GDK_UNMAP);
2714 event->any.window = window;
2716 if (event->any.type == GDK_UNMAP
2717 && p_grab_window == window)
2718 gdk_pointer_ungrab (msg->time);
2720 if (event->any.type == GDK_UNMAP
2721 && k_grab_window == window)
2722 gdk_keyboard_ungrab (msg->time);
2724 return_val = !GDK_WINDOW_DESTROYED (window);
2729 g_print ("WM_SIZE: %#lx %s %dx%d\n",
2731 (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
2732 (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
2733 (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
2734 (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
2735 (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
2736 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2738 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2741 if (msg->wParam == SIZE_MINIMIZED)
2743 event->any.type = GDK_UNMAP;
2744 event->any.window = window;
2746 if (p_grab_window == window)
2747 gdk_pointer_ungrab (msg->time);
2749 if (k_grab_window == window)
2750 gdk_keyboard_ungrab (msg->time);
2752 return_val = !GDK_WINDOW_DESTROYED (window);
2754 else if ((msg->wParam == SIZE_RESTORED
2755 || msg->wParam == SIZE_MAXIMIZED)
2757 && GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2761 if (LOWORD (msg->lParam) == 0)
2764 event->configure.type = GDK_CONFIGURE;
2765 event->configure.window = window;
2768 ClientToScreen (msg->hwnd, &pt);
2769 event->configure.x = pt.x;
2770 event->configure.y = pt.y;
2771 event->configure.width = LOWORD (msg->lParam);
2772 event->configure.height = HIWORD (msg->lParam);
2773 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2774 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2775 window_impl->width = event->configure.width;
2776 window_impl->height = event->configure.height;
2778 if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
2779 GDK_WINDOW_OBJECT (window)->resize_count -= 1;
2781 return_val = !GDK_WINDOW_DESTROYED (window);
2783 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
2784 _gdk_input_configure_event (&event->configure, window);
2790 LPRECT lpr = (LPRECT) msg->lParam;
2791 NONCLIENTMETRICS ncm;
2792 ncm.cbSize = sizeof (NONCLIENTMETRICS);
2794 SystemParametersInfo (SPI_GETNONCLIENTMETRICS, ncm.cbSize, &ncm, 0);
2796 g_print ("WM_SIZING borderWidth %d captionHeight %d\n",
2797 ncm.iBorderWidth, ncm.iCaptionHeight);
2798 event->configure.type = GDK_CONFIGURE;
2799 event->configure.window = window;
2801 event->configure.x = lpr->left + ncm.iBorderWidth;
2802 event->configure.y = lpr->top + ncm.iCaptionHeight;
2803 event->configure.width = lpr->right - lpr->left - 2 * ncm.iBorderWidth;
2804 event->configure.height = lpr->bottom - lpr->top - ncm.iCaptionHeight;
2805 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2806 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2807 window_impl->width = event->configure.width;
2808 window_impl->height = event->configure.height;
2810 if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
2811 GDK_WINDOW_OBJECT (window)->resize_count -= 1;
2813 return_val = !GDK_WINDOW_DESTROYED (window);
2815 && GDK_WINDOW_OBJECT (window)->extension_events != 0)
2816 _gdk_input_configure_event (&event->configure, window);
2820 case WM_GETMINMAXINFO:
2821 GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %#lx\n", (gulong) msg->hwnd));
2823 mmi = (MINMAXINFO*) msg->lParam;
2824 if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
2826 mmi->ptMinTrackSize.x = window_impl->hint_min_width;
2827 mmi->ptMinTrackSize.y = window_impl->hint_min_height;
2829 if (window_impl->hint_flags & GDK_HINT_MAX_SIZE)
2831 mmi->ptMaxTrackSize.x = window_impl->hint_max_width;
2832 mmi->ptMaxTrackSize.y = window_impl->hint_max_height;
2834 /* kind of WM functionality, limit maximized size to screen */
2835 mmi->ptMaxPosition.x = 0; mmi->ptMaxPosition.y = 0;
2836 mmi->ptMaxSize.x = MIN(window_impl->hint_max_width, gdk_screen_width ());
2837 mmi->ptMaxSize.y = MIN(window_impl->hint_max_height, gdk_screen_height ());
2839 else if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
2841 /* need to initialize */
2842 mmi->ptMaxSize.x = gdk_screen_width ();
2843 mmi->ptMaxSize.y = gdk_screen_height ();
2845 /* lovely API inconsistence: return FALSE when handled */
2847 *ret_val_flagp = !(window_impl->hint_flags &
2848 (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
2852 GDK_NOTE (EVENTS, g_print ("WM_MOVE: %#lx (%d,%d)\n",
2854 LOWORD (msg->lParam), HIWORD (msg->lParam)));
2856 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2859 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2860 && !IsIconic(msg->hwnd)
2861 && IsWindowVisible(msg->hwnd))
2863 event->configure.type = GDK_CONFIGURE;
2864 event->configure.window = window;
2865 event->configure.x = LOWORD (msg->lParam);
2866 event->configure.y = HIWORD (msg->lParam);
2867 GetClientRect (msg->hwnd, &rect);
2868 event->configure.width = rect.right;
2869 event->configure.height = rect.bottom;
2870 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2871 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2872 window_impl->width = event->configure.width;
2873 window_impl->height = event->configure.height;
2875 return_val = !GDK_WINDOW_DESTROYED (window);
2878 #if 0 /* not quite right, otherwise it may be faster/better than WM_(MOVE|SIZE)
2879 * remove decoration (frame) sizes ?
2881 case WM_WINDOWPOSCHANGED :
2883 if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2886 if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2887 && !IsIconic(msg->hwnd)
2888 && IsWindowVisible(msg->hwnd))
2890 LPWINDOWPOS lpwp = (LPWINDOWPOS) (msg->lParam);
2892 event->configure.type = GDK_CONFIGURE;
2893 event->configure.window = window;
2894 event->configure.x = lpwp->x;
2895 event->configure.y = lpwp->y;
2896 event->configure.width = lpwp->cx;
2897 event->configure.height = lpwp->cy;
2898 GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2899 GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2900 window_impl->width = event->configure.width;
2901 window_impl->height = event->configure.height;
2903 return_val = !GDK_WINDOW_DESTROYED (window);
2905 GDK_NOTE (EVENTS, g_print ("WM_WINDOWPOSCHANGED: %#lx %ldx%ld@+%ld+%ld\n",
2907 lpwp->cx, lpwp->cy, lpwp->x, lpwp->y));
2910 *ret_val_flagp = TRUE;
2917 GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %#lx\n", (gulong) msg->hwnd));
2919 event->any.type = GDK_DELETE;
2920 event->any.window = window;
2922 return_val = !GDK_WINDOW_DESTROYED (window);
2926 /* No, don't use delayed rendering after all. It works only if the
2927 * delayed SetClipboardData is called from the WindowProc, it
2928 * seems. (The #else part below is test code for that. It succeeds
2929 * in setting the clipboard data. But if I call SetClipboardData
2930 * in gdk_property_change (as a consequence of the
2931 * GDK_SELECTION_REQUEST event), it fails. I deduce that this is
2932 * because delayed rendering requires that SetClipboardData is
2933 * called in the window procedure.)
2935 case WM_RENDERFORMAT:
2936 case WM_RENDERALLFORMATS:
2938 GDK_NOTE (EVENTS, flag = TRUE);
2940 g_print ("WM_%s: %#lx %#x (%s)\n",
2941 (msg->message == WM_RENDERFORMAT ? "RENDERFORMAT" :
2942 "RENDERALLFORMATS"),
2945 (msg->wParam == CF_TEXT ? "CF_TEXT" :
2946 (msg->wParam == CF_DIB ? "CF_DIB" :
2947 (msg->wParam == CF_UNICODETEXT ? "CF_UNICODETEXT" :
2948 (GetClipboardFormatName (msg->wParam, buf, sizeof (buf)), buf)))));
2951 event->selection.type = GDK_SELECTION_REQUEST;
2952 event->selection.window = window;
2953 event->selection.selection = gdk_clipboard_atom;
2954 if (msg->wParam == CF_TEXT)
2955 event->selection.target = GDK_TARGET_STRING;
2958 GetClipboardFormatName (msg->wParam, buf, sizeof (buf));
2959 event->selection.target = gdk_atom_intern (buf, FALSE);
2961 event->selection.property = _gdk_selection_property;
2962 event->selection.requestor = (guint32) msg->hwnd;
2963 event->selection.time = msg->time;
2964 return_val = !GDK_WINDOW_DESTROYED (window);
2966 /* Test code, to see if SetClipboardData works when called from
2967 * the window procedure.
2970 HGLOBAL hdata = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, 10);
2971 char *ptr = GlobalLock (hdata);
2972 strcpy (ptr, "Huhhaa");
2973 GlobalUnlock (hdata);
2974 if (!SetClipboardData (CF_TEXT, hdata))
2975 WIN32_API_FAILED ("SetClipboardData");
2978 *ret_val_flagp = TRUE;
2982 #endif /* No delayed rendering */
2985 GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %#lx\n", (gulong) msg->hwnd));
2987 event->any.type = GDK_DESTROY;
2988 event->any.window = window;
2989 if (window != NULL && window == current_window)
2991 gdk_drawable_unref (current_window);
2992 current_window = NULL;
2995 if (p_grab_window == window)
2996 gdk_pointer_ungrab (msg->time);
2998 if (k_grab_window == window)
2999 gdk_keyboard_ungrab (msg->time);
3001 return_val = window != NULL && !GDK_WINDOW_DESTROYED (window);
3003 if ((window != NULL) && (gdk_root_window != msg->hwnd))
3004 gdk_window_destroy_notify (window);
3009 /* Handle WINTAB events here, as we know that gdkinput.c will
3010 * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
3011 * constants as case labels.
3014 GDK_NOTE (EVENTS, g_print ("WT_PACKET: %#lx %d %#lx\n",
3016 msg->wParam, msg->lParam));
3020 GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %#lx %d %#lx\n",
3022 msg->wParam, msg->lParam));
3026 GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %#lx %#x %d %d\n",
3027 (gulong) msg->hwnd, msg->wParam,
3028 LOWORD (msg->lParam),
3029 HIWORD (msg->lParam)));
3032 event->any.window = window;
3033 return_val = _gdk_input_other_event(event, msg, window);
3038 GDK_NOTE (EVENTS, g_print ("%s: %#lx %#x %#lx\n",
3039 gdk_win32_message_name (msg->message),
3041 msg->wParam, msg->lParam));
3048 if (event->any.window)
3049 gdk_drawable_ref (event->any.window);
3050 if (((event->any.type == GDK_ENTER_NOTIFY) ||
3051 (event->any.type == GDK_LEAVE_NOTIFY)) &&
3052 (event->crossing.subwindow != NULL))
3053 gdk_drawable_ref (event->crossing.subwindow);
3055 GDK_NOTE (EVENTS, print_event (event));
3059 /* Mark this event as having no resources to be freed */
3060 event->any.window = NULL;
3061 event->any.type = GDK_NOTHING;
3065 gdk_drawable_unref (window);
3071 _gdk_events_queue (void)
3077 while (!_gdk_event_queue_find_first ()
3078 && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3080 GDK_NOTE (EVENTS, g_print ("PeekMessage: %#lx %s\n",
3081 (gulong) msg.hwnd, gdk_win32_message_name (msg.message)));
3083 TranslateMessage (&msg);
3085 if (active_imm_msgpump_owner == NULL
3086 || (active_imm_msgpump_owner->lpVtbl->OnTranslateMessage) (active_imm_msgpump_owner, &msg) != S_OK)
3087 TranslateMessage (&msg);
3090 #if 1 /* It was like this all the time */
3091 DispatchMessage (&msg);
3092 #else /* but this one is more similar to the X implementation. Any effect ? */
3093 event = _gdk_event_new ();
3095 event->any.type = GDK_NOTHING;
3096 event->any.window = NULL;
3097 event->any.send_event = InSendMessage ();
3099 ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
3101 _gdk_event_queue_append (event);
3102 node = _gdk_queued_tail;
3104 if (gdk_event_translate (event, &msg, NULL, NULL, FALSE))
3106 ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
3110 _gdk_event_queue_remove_link (node);
3111 g_list_free_1 (node);
3112 gdk_event_free (event);
3113 DispatchMessage (&msg);
3121 gdk_event_prepare (GSource *source,
3127 GDK_THREADS_ENTER ();
3131 retval = (_gdk_event_queue_find_first () != NULL)
3132 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3134 GDK_THREADS_LEAVE ();
3140 gdk_event_check (GSource *source)
3145 GDK_THREADS_ENTER ();
3147 if (event_poll_fd.revents & G_IO_IN)
3148 retval = (_gdk_event_queue_find_first () != NULL)
3149 || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
3153 GDK_THREADS_LEAVE ();
3159 gdk_event_dispatch (GSource *source,
3160 GSourceFunc callback,
3165 GDK_THREADS_ENTER ();
3167 _gdk_events_queue();
3168 event = _gdk_event_unqueue();
3172 if (_gdk_event_func)
3173 (*_gdk_event_func) (event, _gdk_event_data);
3175 gdk_event_free (event);
3178 GDK_THREADS_LEAVE ();
3183 /* Sends a ClientMessage to all toplevel client windows */
3185 gdk_event_send_client_message (GdkEvent *event, guint32 xid)
3192 gdk_event_send_clientmessage_toall (GdkEvent *event)
3203 /* Process all messages currently available */
3204 while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3206 TranslateMessage (&msg); /* Translate virt. key codes */
3207 DispatchMessage (&msg); /* Dispatch msg. to window */
3214 #ifdef G_ENABLE_DEBUG
3217 gdk_win32_message_name (UINT msg)
3219 static gchar bfr[100];
3223 #define CASE(x) case x: return #x
3231 CASE (WM_KILLFOCUS);
3233 CASE (WM_SETREDRAW);
3236 CASE (WM_GETTEXTLENGTH);
3239 CASE (WM_QUERYENDSESSION);
3240 CASE (WM_QUERYOPEN);
3241 CASE (WM_ENDSESSION);
3243 CASE (WM_ERASEBKGND);
3244 CASE (WM_SYSCOLORCHANGE);
3245 CASE (WM_SHOWWINDOW);
3246 CASE (WM_WININICHANGE);
3247 CASE (WM_DEVMODECHANGE);
3248 CASE (WM_ACTIVATEAPP);
3249 CASE (WM_FONTCHANGE);
3250 CASE (WM_TIMECHANGE);
3251 CASE (WM_CANCELMODE);
3252 CASE (WM_SETCURSOR);
3253 CASE (WM_MOUSEACTIVATE);
3254 CASE (WM_CHILDACTIVATE);
3255 CASE (WM_QUEUESYNC);
3256 CASE (WM_GETMINMAXINFO);
3257 CASE (WM_PAINTICON);
3258 CASE (WM_ICONERASEBKGND);
3259 CASE (WM_NEXTDLGCTL);
3260 CASE (WM_SPOOLERSTATUS);
3262 CASE (WM_MEASUREITEM);
3263 CASE (WM_DELETEITEM);
3264 CASE (WM_VKEYTOITEM);
3265 CASE (WM_CHARTOITEM);
3268 CASE (WM_SETHOTKEY);
3269 CASE (WM_GETHOTKEY);
3270 CASE (WM_QUERYDRAGICON);
3271 CASE (WM_COMPAREITEM);
3272 CASE (WM_GETOBJECT);
3273 CASE (WM_COMPACTING);
3274 CASE (WM_WINDOWPOSCHANGING);
3275 CASE (WM_WINDOWPOSCHANGED);
3278 CASE (WM_CANCELJOURNAL);
3280 CASE (WM_INPUTLANGCHANGEREQUEST);
3281 CASE (WM_INPUTLANGCHANGE);
3284 CASE (WM_USERCHANGED);
3285 CASE (WM_NOTIFYFORMAT);
3286 CASE (WM_CONTEXTMENU);
3287 CASE (WM_STYLECHANGING);
3288 CASE (WM_STYLECHANGED);
3289 CASE (WM_DISPLAYCHANGE);
3293 CASE (WM_NCDESTROY);
3294 CASE (WM_NCCALCSIZE);
3295 CASE (WM_NCHITTEST);
3297 CASE (WM_NCACTIVATE);
3298 CASE (WM_GETDLGCODE);
3299 CASE (WM_SYNCPAINT);
3300 CASE (WM_NCMOUSEMOVE);
3301 CASE (WM_NCLBUTTONDOWN);
3302 CASE (WM_NCLBUTTONUP);
3303 CASE (WM_NCLBUTTONDBLCLK);
3304 CASE (WM_NCRBUTTONDOWN);
3305 CASE (WM_NCRBUTTONUP);
3306 CASE (WM_NCRBUTTONDBLCLK);
3307 CASE (WM_NCMBUTTONDOWN);
3308 CASE (WM_NCMBUTTONUP);
3309 CASE (WM_NCMBUTTONDBLCLK);
3310 CASE (WM_NCXBUTTONDOWN);
3311 CASE (WM_NCXBUTTONUP);
3312 CASE (WM_NCXBUTTONDBLCLK);
3317 CASE (WM_SYSKEYDOWN);
3320 CASE (WM_SYSDEADCHAR);
3322 CASE (WM_IME_STARTCOMPOSITION);
3323 CASE (WM_IME_ENDCOMPOSITION);
3324 CASE (WM_IME_COMPOSITION);
3325 CASE (WM_INITDIALOG);
3327 CASE (WM_SYSCOMMAND);
3332 CASE (WM_INITMENUPOPUP);
3333 CASE (WM_MENUSELECT);
3335 CASE (WM_ENTERIDLE);
3336 CASE (WM_MENURBUTTONUP);
3338 CASE (WM_MENUGETOBJECT);
3339 CASE (WM_UNINITMENUPOPUP);
3340 CASE (WM_MENUCOMMAND);
3341 CASE (WM_CHANGEUISTATE);
3342 CASE (WM_UPDATEUISTATE);
3343 CASE (WM_QUERYUISTATE);
3344 CASE (WM_CTLCOLORMSGBOX);
3345 CASE (WM_CTLCOLOREDIT);
3346 CASE (WM_CTLCOLORLISTBOX);
3347 CASE (WM_CTLCOLORBTN);
3348 CASE (WM_CTLCOLORDLG);
3349 CASE (WM_CTLCOLORSCROLLBAR);
3350 CASE (WM_CTLCOLORSTATIC);
3351 CASE (WM_MOUSEMOVE);
3352 CASE (WM_LBUTTONDOWN);
3353 CASE (WM_LBUTTONUP);
3354 CASE (WM_LBUTTONDBLCLK);
3355 CASE (WM_RBUTTONDOWN);
3356 CASE (WM_RBUTTONUP);
3357 CASE (WM_RBUTTONDBLCLK);
3358 CASE (WM_MBUTTONDOWN);
3359 CASE (WM_MBUTTONUP);
3360 CASE (WM_MBUTTONDBLCLK);
3361 CASE (WM_MOUSEWHEEL);
3362 CASE (WM_XBUTTONDOWN);
3363 CASE (WM_XBUTTONUP);
3364 CASE (WM_XBUTTONDBLCLK);
3365 CASE (WM_PARENTNOTIFY);
3366 CASE (WM_ENTERMENULOOP);
3367 CASE (WM_EXITMENULOOP);
3370 CASE (WM_CAPTURECHANGED);
3372 CASE (WM_POWERBROADCAST);
3373 CASE (WM_DEVICECHANGE);
3374 CASE (WM_MDICREATE);
3375 CASE (WM_MDIDESTROY);
3376 CASE (WM_MDIACTIVATE);
3377 CASE (WM_MDIRESTORE);
3379 CASE (WM_MDIMAXIMIZE);
3381 CASE (WM_MDICASCADE);
3382 CASE (WM_MDIICONARRANGE);
3383 CASE (WM_MDIGETACTIVE);
3384 CASE (WM_MDISETMENU);
3385 CASE (WM_ENTERSIZEMOVE);
3386 CASE (WM_EXITSIZEMOVE);
3387 CASE (WM_DROPFILES);
3388 CASE (WM_MDIREFRESHMENU);
3389 CASE (WM_IME_SETCONTEXT);
3390 CASE (WM_IME_NOTIFY);
3391 CASE (WM_IME_CONTROL);
3392 CASE (WM_IME_COMPOSITIONFULL);
3393 CASE (WM_IME_SELECT);
3395 CASE (WM_IME_REQUEST);
3396 CASE (WM_IME_KEYDOWN);
3397 CASE (WM_IME_KEYUP);
3398 CASE (WM_MOUSEHOVER);
3399 CASE (WM_MOUSELEAVE);
3400 CASE (WM_NCMOUSEHOVER);
3401 CASE (WM_NCMOUSELEAVE);
3407 CASE (WM_RENDERFORMAT);
3408 CASE (WM_RENDERALLFORMATS);
3409 CASE (WM_DESTROYCLIPBOARD);
3410 CASE (WM_DRAWCLIPBOARD);
3411 CASE (WM_PAINTCLIPBOARD);
3412 CASE (WM_VSCROLLCLIPBOARD);
3413 CASE (WM_SIZECLIPBOARD);
3414 CASE (WM_ASKCBFORMATNAME);
3415 CASE (WM_CHANGECBCHAIN);
3416 CASE (WM_HSCROLLCLIPBOARD);
3417 CASE (WM_QUERYNEWPALETTE);
3418 CASE (WM_PALETTEISCHANGING);
3419 CASE (WM_PALETTECHANGED);
3422 CASE (WM_PRINTCLIENT);
3423 CASE (WM_APPCOMMAND);
3424 CASE (WM_HANDHELDFIRST);
3425 CASE (WM_HANDHELDLAST);
3428 CASE (WM_PENWINFIRST);
3429 CASE (WM_PENWINLAST);
3433 if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST)
3434 sprintf (bfr, "WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST);
3435 else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST)
3436 sprintf (bfr, "WM_AFXFIRST+%d", msg - WM_AFXFIRST);
3437 else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST)
3438 sprintf (bfr, "WM_PENWINFIRST+%d", msg - WM_PENWINFIRST);
3439 else if (msg >= WM_USER && msg <= 0x7FFF)
3440 sprintf (bfr, "WM_USER+%d", msg - WM_USER);
3441 else if (msg >= 0xC000 && msg <= 0xFFFF)
3442 sprintf (bfr, "reg-%#x", msg);
3444 sprintf (bfr, "unk-%#x", msg);
3447 g_assert_not_reached ();
3450 #endif /* G_ENABLE_DEBUG */