Pileus Git - ~andy/gtk/blob - gdk/win32/gdkevents-win32.c

   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
   4  *
   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.
   9  *
  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.
  14  *
  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.
  19  */
  20
  21 /*
  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/.
  26  */
  27
  28 #include "config.h"
  29
  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.
  36  */
  37 /* define USE_TRACKMOUSEEVENT */
  38
  39 #include <stdio.h>
  40
  41 #include "gdkprivate-win32.h"
  42
  43 #include <objbase.h>
  44 #include <imm.h>
  45
  46 #ifdef HAVE_DIMM_H
  47 #include <dimm.h>
  48 #else
  49 #include "surrogate-dimm.h"
  50 #endif
  51
  52 #include "gdk.h"
  53 #include "gdkinternals.h"
  54 #include "gdkinput-win32.h"
  55
  56 #include "gdkkeysyms.h"
  57
  58 #define PING() printf("%s: %d\n",__FILE__,__LINE__),fflush(stdout)
  59
  60 typedef struct _GdkIOClosure GdkIOClosure;
  61 typedef struct _GdkEventPrivate GdkEventPrivate;
  62
  63 typedef enum
  64 {
  65   /* Following flag is set for events on the event queue during
  66    * translation and cleared afterwards.
  67    */
  68   GDK_EVENT_PENDING = 1 << 0
  69 } GdkEventFlags;
  70
  71 struct _GdkIOClosure
  72 {
  73   GdkInputFunction function;
  74   GdkInputCondition condition;
  75   GdkDestroyNotify notify;
  76   gpointer data;
  77 };
  78
  79 struct _GdkEventPrivate
  80 {
  81   GdkEvent event;
  82   guint    flags;
  83 };
  84
  85 /*
  86  * Private function declarations
  87  */
  88
  89 static GdkFilterReturn
  90                  gdk_event_apply_filters(MSG      *msg,
  91                                          GdkEvent *event,
  92                                          GList    *filters);
  93 static gboolean  gdk_event_translate    (GdkEvent *event,
  94                                          MSG      *msg,
  95                                          gboolean *ret_val_flagp,
  96                                          gint     *ret_valp);
  97
  98 static gboolean gdk_event_prepare  (GSource     *source,
  99                                     gint        *timeout);
 100 static gboolean gdk_event_check    (GSource     *source);
 101 static gboolean gdk_event_dispatch (GSource     *source,
 102                                     GSourceFunc  callback,
 103                                     gpointer     user_data);
 104
 105 /* Private variable declarations
 106  */
 107
 108 static GdkWindow *p_grab_window = NULL; /* Window that currently
 109                                          * holds the pointer grab
 110                                          */
 111
 112 static GdkWindow *k_grab_window = NULL; /* Window the holds the
 113                                          * keyboard grab
 114                                          */
 115
 116 static GList *client_filters;   /* Filters for client messages */
 117
 118 static gboolean p_grab_automatic;
 119 static GdkEventMask p_grab_mask;
 120 static gboolean p_grab_owner_events, k_grab_owner_events;
 121 static HCURSOR p_grab_cursor;
 122
 123 static GSourceFuncs event_funcs = {
 124   gdk_event_prepare,
 125   gdk_event_check,
 126   gdk_event_dispatch,
 127   (GDestroyNotify)g_free
 128 };
 129
 130 GPollFD event_poll_fd;
 131
 132 static GdkWindow *current_window = NULL;
 133 static gint current_x, current_y;
 134 static gdouble current_x_root, current_y_root;
 135 static UINT gdk_ping_msg;
 136 static UINT msh_mousewheel_msg;
 137 static gboolean ignore_wm_char = FALSE;
 138 static gboolean is_altgr_key = FALSE;
 139
 140 static IActiveIMMApp *active_imm_app = NULL;
 141 static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
 142
 143 typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
 144 static PFN_TrackMouseEvent track_mouse_event = NULL;
 145
 146 static gboolean use_ime_composition = FALSE;
 147
 148 static LRESULT
 149 real_window_procedure (HWND   hwnd,
 150                        UINT   message,
 151                        WPARAM wparam,
 152                        LPARAM lparam)
 153 {
 154   GdkEventPrivate event;
 155   GdkEvent *eventp;
 156   MSG msg;
 157   DWORD pos;
 158   LRESULT lres;
 159   gint ret_val;
 160   gboolean ret_val_flag;
 161
 162   msg.hwnd = hwnd;
 163   msg.message = message;
 164   msg.wParam = wparam;
 165   msg.lParam = lparam;
 166   msg.time = GetTickCount ();
 167   pos = GetMessagePos ();
 168   msg.pt.x = LOWORD (pos);
 169   msg.pt.y = HIWORD (pos);
 170
 171   event.flags = GDK_EVENT_PENDING;
 172   if (gdk_event_translate (&event.event, &msg, &ret_val_flag, &ret_val))
 173     {
 174       event.flags &= ~GDK_EVENT_PENDING;
 175 #if 1
 176       if (event.event.any.type == GDK_CONFIGURE)
 177         {
 178           /* Compress configure events */
 179           GList *list = gdk_queued_events;
 180
 181           while (list != NULL
 182                  && (((GdkEvent *)list->data)->any.type != GDK_CONFIGURE
 183                      || ((GdkEvent *)list->data)->any.window != event.event.any.window))
 184             list = list->next;
 185           if (list != NULL)
 186             {
 187               GDK_NOTE (EVENTS, g_print ("... compressing an CONFIGURE event\n"));
 188
 189               *((GdkEvent *)list->data) = event.event;
 190               gdk_drawable_unref (event.event.any.window);
 191               /* Wake up WaitMessage */
 192               PostMessage (NULL, gdk_ping_msg, 0, 0);
 193               return FALSE;
 194             }
 195         }
 196       else if (event.event.any.type == GDK_EXPOSE)
 197         {
 198           /* Compress expose events */
 199           GList *list = gdk_queued_events;
 200
 201           while (list != NULL
 202                  && (((GdkEvent *)list->data)->any.type != GDK_EXPOSE
 203                      || ((GdkEvent *)list->data)->any.window != event.event.any.window))
 204             list = list->next;
 205           if (list != NULL)
 206             {
 207               GdkRectangle u;
 208
 209               GDK_NOTE (EVENTS, g_print ("... compressing an EXPOSE event\n"));
 210               gdk_rectangle_union (&event.event.expose.area,
 211                                    &((GdkEvent *)list->data)->expose.area,
 212                                    &u);
 213               ((GdkEvent *)list->data)->expose.area = u;
 214               gdk_drawable_unref (event.event.any.window);
 215 #if 0
 216               /* Wake up WaitMessage */
 217               PostMessage (NULL, gdk_ping_msg, 0, 0);
 218 #endif
 219               return FALSE;
 220             }
 221         }
 222 #endif
 223       eventp = gdk_event_new ();
 224       *((GdkEventPrivate *) eventp) = event;
 225
 226       /* Philippe Colantoni <colanton@aris.ss.uci.edu> suggests this
 227        * in order to handle events while opaque resizing neatly.  I
 228        * don't want it as default. Set the
 229        * GDK_EVENT_FUNC_FROM_WINDOW_PROC env var to get this
 230        * behaviour.
 231        */
 232       if (gdk_event_func_from_window_proc && gdk_event_func)
 233         {
 234           GDK_THREADS_ENTER ();
 235
 236           (*gdk_event_func) (eventp, gdk_event_data);
 237           gdk_event_free (eventp);
 238
 239           GDK_THREADS_LEAVE ();
 240         }
 241       else
 242         {
 243           gdk_event_queue_append (eventp);
 244 #if 1
 245           /* Wake up WaitMessage */
 246           PostMessage (NULL, gdk_ping_msg, 0, 0);
 247 #endif
 248         }
 249
 250       if (ret_val_flag)
 251         return ret_val;
 252       else
 253         return FALSE;
 254     }
 255
 256   if (ret_val_flag)
 257     return ret_val;
 258   else
 259     {
 260       if (active_imm_app == NULL
 261           || (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
 262         return DefWindowProc (hwnd, message, wparam, lparam);
 263       else
 264         return lres;
 265     }
 266 }
 267
 268 LRESULT CALLBACK
 269 gdk_window_procedure (HWND   hwnd,
 270                       UINT   message,
 271                       WPARAM wparam,
 272                       LPARAM lparam)
 273 {
 274   LRESULT retval;
 275
 276   GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx %s\n",
 277                              (gulong) hwnd, gdk_win32_message_name (message)));
 278
 279   retval = real_window_procedure (hwnd, message, wparam, lparam);
 280
 281   GDK_NOTE (EVENTS, g_print ("gdk_window_procedure: %#lx returns %ld\n",
 282                              (gulong) hwnd, retval));
 283
 284   return retval;
 285 }
 286
 287 void
 288 gdk_events_init (void)
 289 {
 290   GSource *source;
 291   HRESULT hres;
 292 #ifdef USE_TRACKMOUSEEVENT
 293   HMODULE user32, imm32;
 294   HINSTANCE commctrl32;
 295 #endif
 296
 297   gdk_ping_msg = RegisterWindowMessage ("gdk-ping");
 298   GDK_NOTE (EVENTS, g_print ("gdk-ping = %#x\n", gdk_ping_msg));
 299
 300   /* This is the string MSH_MOUSEWHEEL from zmouse.h,
 301    * http://www.microsoft.com/mouse/intellimouse/sdk/zmouse.h
 302    * This message is used by mouse drivers than cannot generate WM_MOUSEWHEEL
 303    * or on Win95.
 304    */
 305   msh_mousewheel_msg = RegisterWindowMessage ("MSWHEEL_ROLLMSG");
 306   GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL = %#x\n", msh_mousewheel_msg));
 307
 308   source = g_source_new (&event_funcs, sizeof (GSource));
 309   g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 310
 311   event_poll_fd.fd = G_WIN32_MSG_HANDLE;
 312   event_poll_fd.events = G_IO_IN;
 313
 314   g_source_add_poll (source, &event_poll_fd);
 315   g_source_set_can_recurse (source, TRUE);
 316   g_source_attach (source, NULL);
 317
 318   g_source_add (GDK_PRIORITY_EVENTS, TRUE, &event_funcs, NULL, NULL, NULL);
 319
 320   hres = CoCreateInstance (&CLSID_CActiveIMM,
 321                            NULL,
 322                            CLSCTX_ALL,
 323                            &IID_IActiveIMMApp,
 324                            (LPVOID *) &active_imm_app);
 325
 326   if (hres == S_OK)
 327     {
 328       GDK_NOTE (EVENTS, g_print ("IActiveIMMApp created %p\n",
 329                                  active_imm_app));
 330       (*active_imm_app->lpVtbl->Activate) (active_imm_app, TRUE);
 331
 332       hres = (*active_imm_app->lpVtbl->QueryInterface) (active_imm_app, &IID_IActiveIMMMessagePumpOwner, &active_imm_msgpump_owner);
 333       GDK_NOTE (EVENTS, g_print ("IActiveIMMMessagePumpOwner created %p\n",
 334                                  active_imm_msgpump_owner));
 335       (active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
 336     }
 337
 338 #ifdef USE_TRACKMOUSEEVENT
 339   user32 = GetModuleHandle ("user32.dll");
 340   if ((track_mouse_event = GetProcAddress (user32, "TrackMouseEvent")) == NULL)
 341     {
 342       if ((commctrl32 = LoadLibrary ("commctrl32.dll")) != NULL)
 343         track_mouse_event = (PFN_TrackMouseEvent)
 344           GetProcAddress (commctrl32, "_TrackMouseEvent");
 345     }
 346   if (track_mouse_event != NULL)
 347     GDK_NOTE (EVENTS, g_print ("Using TrackMouseEvent to detect leave events\n"));
 348 #endif
 349   if (IS_WIN_NT () && (windows_version & 0xFF) == 5)
 350     {
 351       /* On Win2k (Beta 3, at least) WM_IME_CHAR doesn't seem to work
 352        * correctly for non-Unicode applications. Handle
 353        * WM_IME_COMPOSITION with GCS_RESULTSTR instead, fetch the
 354        * Unicode char from the IME with ImmGetCompositionStringW().
 355        */
 356       use_ime_composition = TRUE;
 357     }
 358 }
 359
 360 /*
 361  *--------------------------------------------------------------
 362  * gdk_events_pending
 363  *
 364  *   Returns if events are pending on the queue.
 365  *
 366  * Arguments:
 367  *
 368  * Results:
 369  *   Returns TRUE if events are pending
 370  *
 371  * Side effects:
 372  *
 373  *--------------------------------------------------------------
 374  */
 375
 376 gboolean
 377 gdk_events_pending (void)
 378 {
 379   MSG msg;
 380
 381   return (gdk_event_queue_find_first() ||
 382           PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
 383 }
 384
 385 /*
 386  *--------------------------------------------------------------
 387  * gdk_event_get_graphics_expose
 388  *
 389  *   Waits for a GraphicsExpose or NoExpose event
 390  *
 391  * Arguments:
 392  *
 393  * Results:
 394  *   For GraphicsExpose events, returns a pointer to the event
 395  *   converted into a GdkEvent Otherwise, returns NULL.
 396  *
 397  * Side effects:
 398  *
 399  *-------------------------------------------------------------- */
 400
 401 GdkEvent*
 402 gdk_event_get_graphics_expose (GdkWindow *window)
 403 {
 404   MSG msg;
 405   GdkEvent *event;
 406
 407   g_return_val_if_fail (window != NULL, NULL);
 408
 409   GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));
 410
 411 #if 0 /* ??? */
 412   /* Some nasty bugs here, just return NULL for now. */
 413   return NULL;
 414 #else
 415   if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
 416     {
 417       event = gdk_event_new ();
 418
 419       if (gdk_event_translate (event, &msg, NULL, NULL))
 420         return event;
 421       else
 422         gdk_event_free (event);
 423     }
 424
 425   return NULL;
 426 #endif
 427 }
 428
 429 static char *
 430 event_mask_string (GdkEventMask mask)
 431 {
 432   static char bfr[500];
 433   char *p = bfr;
 434
 435   *p = '\0';
 436 #define BIT(x) \
 437   if (mask & GDK_##x##_MASK) \
 438     p += sprintf (p, "%s" #x, (p > bfr ? " " : ""))
 439   BIT(EXPOSURE);
 440   BIT(POINTER_MOTION);
 441   BIT(POINTER_MOTION_HINT);
 442   BIT(BUTTON_MOTION);
 443   BIT(BUTTON1_MOTION);
 444   BIT(BUTTON2_MOTION);
 445   BIT(BUTTON3_MOTION);
 446   BIT(BUTTON_PRESS);
 447   BIT(BUTTON_RELEASE);
 448   BIT(KEY_PRESS);
 449   BIT(KEY_RELEASE);
 450   BIT(ENTER_NOTIFY);
 451   BIT(LEAVE_NOTIFY);
 452   BIT(FOCUS_CHANGE);
 453   BIT(STRUCTURE);
 454   BIT(PROPERTY_CHANGE);
 455   BIT(VISIBILITY_NOTIFY);
 456   BIT(PROXIMITY_IN);
 457   BIT(PROXIMITY_OUT);
 458   BIT(SUBSTRUCTURE);
 459   BIT(SCROLL);
 460 #undef BIT
 461
 462   return bfr;
 463 }
 464
 465 /*
 466  *--------------------------------------------------------------
 467  * gdk_pointer_grab
 468  *
 469  *   Grabs the pointer to a specific window
 470  *
 471  * Arguments:
 472  *   "window" is the window which will receive the grab
 473  *   "owner_events" specifies whether events will be reported as is,
 474  *     or relative to "window"
 475  *   "event_mask" masks only interesting events
 476  *   "confine_to" limits the cursor movement to the specified window
 477  *   "cursor" changes the cursor for the duration of the grab
 478  *   "time" specifies the time
 479  *
 480  * Results:
 481  *
 482  * Side effects:
 483  *   requires a corresponding call to gdk_pointer_ungrab
 484  *
 485  *--------------------------------------------------------------
 486  */
 487
 488 GdkGrabStatus
 489 gdk_pointer_grab (GdkWindow    *window,
 490                   gboolean      owner_events,
 491                   GdkEventMask  event_mask,
 492                   GdkWindow    *confine_to,
 493                   GdkCursor    *cursor,
 494                   guint32       time)
 495 {
 496   HWND hwnd_confined_to;
 497   HCURSOR hcursor;
 498   GdkCursorPrivate *cursor_private;
 499   gint return_val;
 500
 501   g_return_val_if_fail (window != NULL, 0);
 502   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 503   g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
 504
 505   cursor_private = (GdkCursorPrivate*) cursor;
 506
 507   if (!confine_to || GDK_WINDOW_DESTROYED (confine_to))
 508     hwnd_confined_to = NULL;
 509   else
 510     hwnd_confined_to = GDK_WINDOW_HWND (confine_to);
 511
 512   if (!cursor)
 513     hcursor = NULL;
 514   else
 515     hcursor = cursor_private->hcursor;
 516
 517   return_val = _gdk_input_grab_pointer (window,
 518                                         owner_events,
 519                                         event_mask,
 520                                         confine_to,
 521                                         time);
 522
 523   if (return_val == GDK_GRAB_SUCCESS)
 524     {
 525       if (!GDK_WINDOW_DESTROYED (window))
 526         {
 527           GDK_NOTE (EVENTS, g_print ("gdk_pointer_grab: %#lx %s %#lx %s\n",
 528                                      (gulong) GDK_WINDOW_HWND (window),
 529                                      (owner_events ? "TRUE" : "FALSE"),
 530                                      (gulong) hcursor,
 531                                      event_mask_string (event_mask)));
 532           p_grab_mask = event_mask;
 533           p_grab_owner_events = (owner_events != 0);
 534           p_grab_automatic = FALSE;
 535
 536 #if 0 /* Menus don't work if we use mouse capture. Pity, because many other
 537        * things work better with mouse capture.
 538        */
 539           SetCapture (GDK_WINDOW_HWND (window));
 540 #       pragma message("Warning: SetCapture call, menus won't work!")
 541 #endif
 542           return_val = GDK_GRAB_SUCCESS;
 543         }
 544       else
 545         return_val = GDK_GRAB_ALREADY_GRABBED;
 546     }
 547
 548   if (return_val == GDK_GRAB_SUCCESS)
 549     {
 550       p_grab_window = window;
 551       p_grab_cursor = hcursor;
 552     }
 553
 554   return return_val;
 555 }
 556
 557 /*
 558  *--------------------------------------------------------------
 559  * gdk_pointer_ungrab
 560  *
 561  *   Releases any pointer grab
 562  *
 563  * Arguments:
 564  *
 565  * Results:
 566  *
 567  * Side effects:
 568  *
 569  *--------------------------------------------------------------
 570  */
 571
 572 void
 573 gdk_pointer_ungrab (guint32 time)
 574 {
 575   GDK_NOTE (EVENTS, g_print ("gdk_pointer_ungrab\n"));
 576
 577   _gdk_input_ungrab_pointer (time);
 578
 579 #if 1
 580   if (GetCapture () != NULL)
 581     ReleaseCapture ();
 582 #endif
 583
 584   p_grab_window = NULL;
 585 }
 586
 587 /*
 588  *--------------------------------------------------------------
 589  * gdk_pointer_is_grabbed
 590  *
 591  *   Tell wether there is an active x pointer grab in effect
 592  *
 593  * Arguments:
 594  *
 595  * Results:
 596  *
 597  * Side effects:
 598  *
 599  *--------------------------------------------------------------
 600  */
 601
 602 gboolean
 603 gdk_pointer_is_grabbed (void)
 604 {
 605   return p_grab_window != NULL;
 606 }
 607
 608 /*
 609  *--------------------------------------------------------------
 610  * gdk_keyboard_grab
 611  *
 612  *   Grabs the keyboard to a specific window
 613  *
 614  * Arguments:
 615  *   "window" is the window which will receive the grab
 616  *   "owner_events" specifies whether events will be reported as is,
 617  *     or relative to "window"
 618  *   "time" specifies the time
 619  *
 620  * Results:
 621  *
 622  * Side effects:
 623  *   requires a corresponding call to gdk_keyboard_ungrab
 624  *
 625  *--------------------------------------------------------------
 626  */
 627
 628 GdkGrabStatus
 629 gdk_keyboard_grab (GdkWindow *window,
 630                    gboolean   owner_events,
 631                    guint32    time)
 632 {
 633   gint return_val;
 634
 635   g_return_val_if_fail (window != NULL, 0);
 636   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 637
 638   GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %#lx\n",
 639                              (gulong) GDK_WINDOW_HWND (window)));
 640
 641   if (!GDK_WINDOW_DESTROYED (window))
 642     {
 643       k_grab_owner_events = owner_events != 0;
 644       return_val = GDK_GRAB_SUCCESS;
 645     }
 646   else
 647     return_val = GDK_GRAB_ALREADY_GRABBED;
 648
 649   if (return_val == GDK_GRAB_SUCCESS)
 650     k_grab_window = window;
 651
 652   return return_val;
 653 }
 654
 655 /*
 656  *--------------------------------------------------------------
 657  * gdk_keyboard_ungrab
 658  *
 659  *   Releases any keyboard grab
 660  *
 661  * Arguments:
 662  *
 663  * Results:
 664  *
 665  * Side effects:
 666  *
 667  *--------------------------------------------------------------
 668  */
 669
 670 void
 671 gdk_keyboard_ungrab (guint32 time)
 672 {
 673   GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));
 674
 675   k_grab_window = NULL;
 676 }
 677
 678 static GdkFilterReturn
 679 gdk_event_apply_filters (MSG      *msg,
 680                          GdkEvent *event,
 681                          GList    *filters)
 682 {
 683   GdkEventFilter *filter;
 684   GList *tmp_list;
 685   GdkFilterReturn result;
 686
 687   tmp_list = filters;
 688
 689   while (tmp_list)
 690     {
 691       filter = (GdkEventFilter *) tmp_list->data;
 692
 693       result = (*filter->function) (msg, event, filter->data);
 694       if (result !=  GDK_FILTER_CONTINUE)
 695         return result;
 696
 697       tmp_list = tmp_list->next;
 698     }
 699
 700   return GDK_FILTER_CONTINUE;
 701 }
 702
 703 void
 704 gdk_add_client_message_filter (GdkAtom       message_type,
 705                                GdkFilterFunc func,
 706                                gpointer      data)
 707 {
 708   GdkClientFilter *filter = g_new (GdkClientFilter, 1);
 709
 710   filter->type = message_type;
 711   filter->function = func;
 712   filter->data = data;
 713
 714   client_filters = g_list_prepend (client_filters, filter);
 715 }
 716
 717 /* Thanks to Markus G. Kuhn <mkuhn@acm.org> for the ksysym<->Unicode
 718  * mapping functions, from the xterm sources.
 719  */
 720
 721 static void
 722 build_key_event_state (GdkEvent *event)
 723 {
 724   if (GetKeyState (VK_SHIFT) < 0)
 725     event->key.state |= GDK_SHIFT_MASK;
 726   if (GetKeyState (VK_CAPITAL) & 0x1)
 727     event->key.state |= GDK_LOCK_MASK;
 728   if (!is_altgr_key)
 729     {
 730       if (GetKeyState (VK_CONTROL) < 0)
 731         {
 732           event->key.state |= GDK_CONTROL_MASK;
 733 #if 0
 734           if (event->key.keyval < ' ')
 735             event->key.keyval += '@';
 736 #endif
 737         }
 738 #if 0
 739       else if (event->key.keyval < ' ')
 740         {
 741           event->key.state |= GDK_CONTROL_MASK;
 742           event->key.keyval += '@';
 743         }
 744 #endif
 745       if (GetKeyState (VK_MENU) < 0)
 746         event->key.state |= GDK_MOD1_MASK;
 747     }
 748 }
 749
 750 static gint
 751 build_pointer_event_state (MSG *msg)
 752 {
 753   gint state;
 754
 755   state = 0;
 756   if (msg->wParam & MK_CONTROL)
 757     state |= GDK_CONTROL_MASK;
 758   if (msg->wParam & MK_LBUTTON)
 759     state |= GDK_BUTTON1_MASK;
 760   if (msg->wParam & MK_MBUTTON)
 761     state |= GDK_BUTTON2_MASK;
 762   if (msg->wParam & MK_RBUTTON)
 763     state |= GDK_BUTTON3_MASK;
 764   if (msg->wParam & MK_SHIFT)
 765     state |= GDK_SHIFT_MASK;
 766   if (GetKeyState (VK_MENU) < 0)
 767     state |= GDK_MOD1_MASK;
 768   if (GetKeyState (VK_CAPITAL) & 0x1)
 769     state |= GDK_LOCK_MASK;
 770
 771   return state;
 772 }
 773
 774 static void
 775 build_keypress_event (GdkWindowImplWin32 *impl,
 776                       GdkEvent           *event,
 777                       MSG                *msg)
 778 {
 779   HIMC himc;
 780   gint i, bytecount, ucount, ucleft, len;
 781   guchar buf[100], *bp;
 782   wchar_t wbuf[100], *wcp;
 783
 784   event->key.type = GDK_KEY_PRESS;
 785   event->key.time = msg->time;
 786   event->key.state = 0;
 787
 788   if (msg->message == WM_IME_COMPOSITION)
 789     {
 790       himc = ImmGetContext (msg->hwnd);
 791
 792       bytecount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
 793                                             wbuf, sizeof (wbuf));
 794       ucount = bytecount / 2;
 795     }
 796   else
 797     {
 798       if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
 799         {
 800           bytecount = MIN ((msg->lParam & 0xFFFF), sizeof (buf));
 801           for (i = 0; i < bytecount; i++)
 802             buf[i] = msg->wParam;
 803         }
 804       else /* WM_IME_CHAR */
 805         {
 806           event->key.keyval = GDK_VoidSymbol;
 807           if (msg->wParam & 0xFF00)
 808             {
 809               /* Contrary to some versions of the documentation,
 810                * the lead byte is the most significant byte.
 811                */
 812               buf[0] = ((msg->wParam >> 8) & 0xFF);
 813               buf[1] = (msg->wParam & 0xFF);
 814               bytecount = 2;
 815             }
 816           else
 817             {
 818               buf[0] = (msg->wParam & 0xFF);
 819               bytecount = 1;
 820             }
 821         }
 822
 823       /* Convert from the window's current code page
 824        * to Unicode. Then convert to UTF-8.
 825        * We don't handle the surrogate stuff. Should we?
 826        */
 827       ucount = MultiByteToWideChar (impl->charset_info.ciACP,
 828                                     0, buf, bytecount,
 829                                     wbuf, sizeof (wbuf) / sizeof (wbuf[0]));
 830
 831     }
 832   if (ucount == 0)
 833     event->key.keyval = GDK_VoidSymbol;
 834   else if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
 835     {
 836       if (msg->wParam < ' ')
 837         {
 838           event->key.keyval = msg->wParam + '@';
 839           /* This is needed in case of Alt+nnn or Alt+0nnn (on the numpad)
 840            * where nnn<32
 841            */
 842           event->key.state |= GDK_CONTROL_MASK;
 843         }
 844       else
 845         event->key.keyval = gdk_unicode_to_keyval (wbuf[0]);
 846     }
 847
 848   build_key_event_state (event);
 849
 850   /* Build UTF-8 string */
 851   ucleft = ucount;
 852   len = 0;
 853   wcp = wbuf;
 854   while (ucleft-- > 0)
 855     {
 856       wchar_t c = *wcp++;
 857
 858       if (c < 0x80)
 859         len += 1;
 860       else if (c < 0x800)
 861         len += 2;
 862       else
 863         len += 3;
 864     }
 865
 866   event->key.string = g_malloc (len + 1);
 867   event->key.length = len;
 868
 869   ucleft = ucount;
 870   wcp = wbuf;
 871   bp = event->key.string;
 872   while (ucleft-- > 0)
 873     {
 874       int first;
 875       wchar_t c = *wcp++;
 876
 877       if (c < 0x80)
 878         {
 879           first = 0;
 880           len = 1;
 881         }
 882       else if (c < 0x800)
 883         {
 884           first = 0xc0;
 885           len = 2;
 886         }
 887       else
 888         {
 889           first = 0xe0;
 890           len = 3;
 891         }
 892
 893 #if 1
 894       /* Woo-hoo! */
 895       switch (len)
 896         {
 897         case 3: bp[2] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
 898         case 2: bp[1] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
 899         case 1: bp[0] = c | first;
 900         }
 901 #else
 902       for (i = len - 1; i > 0; --i)
 903         {
 904           bp[i] = (c & 0x3f) | 0x80;
 905           c >>= 6;
 906         }
 907       bp[0] = c | first;
 908 #endif
 909
 910       bp += len;
 911     }
 912   *bp = 0;
 913 }
 914
 915 static void
 916 build_keyrelease_event (GdkWindowImplWin32 *impl,
 917                         GdkEvent           *event,
 918                         MSG                *msg)
 919 {
 920   guchar buf;
 921   wchar_t wbuf;
 922
 923   event->key.type = GDK_KEY_RELEASE;
 924   event->key.time = msg->time;
 925   event->key.state = 0;
 926
 927   if (msg->message == WM_CHAR || msg->message == WM_SYSCHAR)
 928     if (msg->wParam < ' ')
 929       event->key.keyval = msg->wParam + '@';
 930     else
 931       {
 932         buf = msg->wParam;
 933         MultiByteToWideChar (impl->charset_info.ciACP,
 934                              0, &buf, 1, &wbuf, 1);
 935
 936         event->key.keyval = gdk_unicode_to_keyval (wbuf);
 937       }
 938   else
 939     event->key.keyval = GDK_VoidSymbol;
 940   build_key_event_state (event);
 941   event->key.string = NULL;
 942   event->key.length = 0;
 943 }
 944
 945 static void
 946 print_event_state (gint state)
 947 {
 948   if (state & GDK_SHIFT_MASK)
 949     g_print ("SHIFT ");
 950   if (state & GDK_LOCK_MASK)
 951     g_print ("LOCK ");
 952   if (state & GDK_CONTROL_MASK)
 953     g_print ("CONTROL ");
 954   if (state & GDK_MOD1_MASK)
 955     g_print ("MOD1 ");
 956   if (state & GDK_BUTTON1_MASK)
 957     g_print ("BUTTON1 ");
 958   if (state & GDK_BUTTON2_MASK)
 959     g_print ("BUTTON2 ");
 960   if (state & GDK_BUTTON3_MASK)
 961     g_print ("BUTTON3 ");
 962 }
 963
 964 static void
 965 print_event (GdkEvent *event)
 966 {
 967   gchar *escaped, *kvname;
 968
 969   switch (event->any.type)
 970     {
 971     case GDK_NOTHING: g_print ("GDK_NOTHING "); break;
 972     case GDK_DELETE: g_print ("GDK_DELETE "); break;
 973     case GDK_DESTROY: g_print ("GDK_DESTROY "); break;
 974     case GDK_EXPOSE: g_print ("GDK_EXPOSE "); break;
 975     case GDK_MOTION_NOTIFY: g_print ("GDK_MOTION_NOTIFY "); break;
 976     case GDK_BUTTON_PRESS: g_print ("GDK_BUTTON_PRESS "); break;
 977     case GDK_2BUTTON_PRESS: g_print ("GDK_2BUTTON_PRESS "); break;
 978     case GDK_3BUTTON_PRESS: g_print ("GDK_3BUTTON_PRESS "); break;
 979     case GDK_BUTTON_RELEASE: g_print ("GDK_BUTTON_RELEASE "); break;
 980     case GDK_KEY_PRESS: g_print ("GDK_KEY_PRESS "); break;
 981     case GDK_KEY_RELEASE: g_print ("GDK_KEY_RELEASE "); break;
 982     case GDK_ENTER_NOTIFY: g_print ("GDK_ENTER_NOTIFY "); break;
 983     case GDK_LEAVE_NOTIFY: g_print ("GDK_LEAVE_NOTIFY "); break;
 984     case GDK_FOCUS_CHANGE: g_print ("GDK_FOCUS_CHANGE "); break;
 985     case GDK_CONFIGURE: g_print ("GDK_CONFIGURE "); break;
 986     case GDK_MAP: g_print ("GDK_MAP "); break;
 987     case GDK_UNMAP: g_print ("GDK_UNMAP "); break;
 988     case GDK_PROPERTY_NOTIFY: g_print ("GDK_PROPERTY_NOTIFY "); break;
 989     case GDK_SELECTION_CLEAR: g_print ("GDK_SELECTION_CLEAR "); break;
 990     case GDK_SELECTION_REQUEST: g_print ("GDK_SELECTION_REQUEST "); break;
 991     case GDK_SELECTION_NOTIFY: g_print ("GDK_SELECTION_NOTIFY "); break;
 992     case GDK_PROXIMITY_IN: g_print ("GDK_PROXIMITY_IN "); break;
 993     case GDK_PROXIMITY_OUT: g_print ("GDK_PROXIMITY_OUT "); break;
 994     case GDK_DRAG_ENTER: g_print ("GDK_DRAG_ENTER "); break;
 995     case GDK_DRAG_LEAVE: g_print ("GDK_DRAG_LEAVE "); break;
 996     case GDK_DRAG_MOTION: g_print ("GDK_DRAG_MOTION "); break;
 997     case GDK_DRAG_STATUS: g_print ("GDK_DRAG_STATUS "); break;
 998     case GDK_DROP_START: g_print ("GDK_DROP_START "); break;
 999     case GDK_DROP_FINISHED: g_print ("GDK_DROP_FINISHED "); break;
1000     case GDK_CLIENT_EVENT: g_print ("GDK_CLIENT_EVENT "); break;
1001     case GDK_VISIBILITY_NOTIFY: g_print ("GDK_VISIBILITY_NOTIFY "); break;
1002     case GDK_NO_EXPOSE: g_print ("GDK_NO_EXPOSE "); break;
1003     case GDK_SCROLL: g_print ("GDK_SCROLL "); break;
1004     }
1005   g_print ("%#lx ", (gulong) GDK_WINDOW_HWND (event->any.window));
1006
1007   switch (event->any.type)
1008     {
1009     case GDK_EXPOSE:
1010       g_print ("%dx%d@+%d+%d %d",
1011                event->expose.area.width,
1012                event->expose.area.height,
1013                event->expose.area.x,
1014                event->expose.area.y,
1015                event->expose.count);
1016       break;
1017     case GDK_MOTION_NOTIFY:
1018       g_print ("(%.4g,%.4g) %s",
1019                event->motion.x, event->motion.y,
1020                event->motion.is_hint ? "HINT " : "");
1021       print_event_state (event->motion.state);
1022       break;
1023     case GDK_BUTTON_PRESS:
1024     case GDK_2BUTTON_PRESS:
1025     case GDK_3BUTTON_PRESS:
1026     case GDK_BUTTON_RELEASE:
1027       g_print ("%d (%.4g,%.4g) ",
1028                event->button.button,
1029                event->button.x, event->button.y);
1030       print_event_state (event->button.state);
1031       break;
1032     case GDK_KEY_PRESS:
1033     case GDK_KEY_RELEASE:
1034       if (event->key.length == 0)
1035         escaped = g_strdup ("");
1036       else
1037         escaped = g_strescape (event->key.string, NULL);
1038       kvname = gdk_keyval_name (event->key.keyval);
1039       g_print ("%s %d:\"%s\" ",
1040                (kvname ? kvname : "??"),
1041                event->key.length,
1042                escaped);
1043       g_free (escaped);
1044       print_event_state (event->key.state);
1045       break;
1046     case GDK_ENTER_NOTIFY:
1047     case GDK_LEAVE_NOTIFY:
1048       g_print ("%s ",
1049                (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
1050                 (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
1051                  (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
1052                   "???"))));
1053       break;
1054     case GDK_SCROLL:
1055       g_print ("%s ",
1056                (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
1057                 (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
1058                  (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
1059                   (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
1060                    "???")))));
1061       print_event_state (event->scroll.state);
1062       break;
1063     default:
1064       /* Nothing */
1065       break;
1066     }
1067   g_print ("\n");
1068 }
1069
1070 static void
1071 synthesize_crossing_events (GdkWindow *window,
1072                             MSG       *msg)
1073 {
1074   GdkEvent *event;
1075
1076   /* If we are not using TrackMouseEvent, generate a leave notify
1077    * event if necessary
1078    */
1079   if (track_mouse_event == NULL
1080       && current_window
1081       && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1082     {
1083       GDK_NOTE (EVENTS, g_print ("synthesizing LEAVE_NOTIFY event\n"));
1084
1085       event = gdk_event_new ();
1086       event->crossing.type = GDK_LEAVE_NOTIFY;
1087       event->crossing.window = current_window;
1088       gdk_drawable_ref (event->crossing.window);
1089       event->crossing.subwindow = NULL;
1090       event->crossing.time = msg->time;
1091       event->crossing.x = current_x;
1092       event->crossing.y = current_y;
1093       event->crossing.x_root = current_x_root;
1094       event->crossing.y_root = current_y_root;
1095       event->crossing.mode = GDK_CROSSING_NORMAL;
1096       if (IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
1097         event->crossing.detail = GDK_NOTIFY_INFERIOR;
1098       else if (IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
1099         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1100       else
1101         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
1102
1103       event->crossing.focus = TRUE; /* ??? */
1104       event->crossing.state = 0; /* ??? */
1105
1106       gdk_event_queue_append (event);
1107       GDK_NOTE (EVENTS, print_event (event));
1108     }
1109
1110   if (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->event_mask & GDK_ENTER_NOTIFY_MASK)
1111     {
1112       GDK_NOTE (EVENTS, g_print ("synthesizing ENTER_NOTIFY event\n"));
1113
1114       event = gdk_event_new ();
1115       event->crossing.type = GDK_ENTER_NOTIFY;
1116       event->crossing.window = window;
1117       gdk_drawable_ref (event->crossing.window);
1118       event->crossing.subwindow = NULL;
1119       event->crossing.time = msg->time;
1120       event->crossing.x = LOWORD (msg->lParam);
1121       event->crossing.y = HIWORD (msg->lParam);
1122       event->crossing.x_root = (gfloat) msg->pt.x;
1123       event->crossing.y_root = (gfloat) msg->pt.y;
1124       event->crossing.mode = GDK_CROSSING_NORMAL;
1125       if (current_window
1126           && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
1127         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
1128       else if (current_window
1129                && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
1130         event->crossing.detail = GDK_NOTIFY_INFERIOR;
1131       else
1132         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
1133
1134       event->crossing.focus = TRUE; /* ??? */
1135       event->crossing.state = 0; /* ??? */
1136
1137       gdk_event_queue_append (event);
1138
1139       GDK_NOTE (EVENTS, print_event (event));
1140
1141       if (GDK_WINDOW_OBJECT (window)->extension_events != 0)
1142         _gdk_input_enter_event (&event->crossing, window);
1143     }
1144
1145   if (current_window)
1146     gdk_drawable_unref (current_window);
1147   current_window = window;
1148   gdk_drawable_ref (current_window);
1149 #ifdef USE_TRACKMOUSEEVENT
1150   if (track_mouse_event != NULL)
1151     {
1152       TRACKMOUSEEVENT tme;
1153
1154       tme.cbSize = sizeof (TRACKMOUSEEVENT);
1155       tme.dwFlags = TME_LEAVE;
1156       tme.hwndTrack = GDK_WINDOW_HWND (current_window);
1157       tme.dwHoverTime = HOVER_DEFAULT;
1158
1159       (*track_mouse_event) (&tme);
1160     }
1161 #endif
1162 }
1163
1164 static void
1165 translate_mouse_coords (GdkWindow *window1,
1166                         GdkWindow *window2,
1167                         MSG       *msg)
1168 {
1169   POINT pt;
1170
1171   pt.x = LOWORD (msg->lParam);
1172   pt.y = HIWORD (msg->lParam);
1173   ClientToScreen (GDK_WINDOW_HWND (window1), &pt);
1174   ScreenToClient (GDK_WINDOW_HWND (window2), &pt);
1175   msg->lParam = MAKELPARAM (pt.x, pt.y);
1176   GDK_NOTE (EVENTS, g_print ("...new coords are (%ld,%ld)\n", pt.x, pt.y));
1177 }
1178
1179 static gboolean
1180 propagate (GdkWindow  **window,
1181            MSG         *msg,
1182            GdkWindow   *grab_window,
1183            gboolean     grab_owner_events,
1184            gint         grab_mask,
1185            gboolean   (*doesnt_want_it) (gint mask,
1186                                          MSG *msg))
1187 {
1188   if (grab_window != NULL && !grab_owner_events)
1189     {
1190       /* Event source is grabbed with owner_events FALSE */
1191       GDK_NOTE (EVENTS, g_print ("...grabbed, owner_events FALSE, "));
1192       if ((*doesnt_want_it) (grab_mask, msg))
1193         {
1194           GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1195           return FALSE;
1196         }
1197       else
1198         {
1199           GDK_NOTE (EVENTS, g_print ("...sending to grabber %#lx\n",
1200                                      (gulong) GDK_WINDOW_HWND (grab_window)));
1201           gdk_drawable_unref (*window);
1202           *window = grab_window;
1203           gdk_drawable_ref (*window);
1204           return TRUE;
1205         }
1206     }
1207   while (TRUE)
1208     {
1209      if ((*doesnt_want_it) (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (*window)->impl)->event_mask, msg))
1210         {
1211           /* Owner doesn't want it, propagate to parent. */
1212           if (GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent) == gdk_parent_root)
1213             {
1214               /* No parent; check if grabbed */
1215               if (grab_window != NULL)
1216                 {
1217                   /* Event source is grabbed with owner_events TRUE */
1218                   GDK_NOTE (EVENTS, g_print ("...undelivered, but grabbed\n"));
1219                   if ((*doesnt_want_it) (grab_mask, msg))
1220                     {
1221                       /* Grabber doesn't want it either */
1222                       GDK_NOTE (EVENTS, g_print ("...grabber doesn't want it\n"));
1223                       return FALSE;
1224                     }
1225                   else
1226                     {
1227                       /* Grabbed! */
1228                       GDK_NOTE (EVENTS,
1229                                 g_print ("...sending to grabber %#lx\n",
1230                                          (gulong) GDK_WINDOW_HWND (grab_window)));
1231                       gdk_drawable_unref (*window);
1232                       *window = grab_window;
1233                       gdk_drawable_ref (*window);
1234                       return TRUE;
1235                     }
1236                 }
1237               else
1238                 {
1239                   GDK_NOTE (EVENTS, g_print ("...undelivered\n"));
1240                   return FALSE;
1241                 }
1242             }
1243           else
1244             {
1245               gdk_drawable_unref (*window);
1246               *window = GDK_WINDOW (GDK_WINDOW_OBJECT (*window)->parent);
1247               gdk_drawable_ref (*window);
1248               GDK_NOTE (EVENTS, g_print ("...propagating to %#lx\n",
1249                                          (gulong) GDK_WINDOW_HWND (*window)));
1250               /* The only branch where we actually continue the loop */
1251             }
1252         }
1253       else
1254         return TRUE;
1255     }
1256 }
1257
1258 static gboolean
1259 doesnt_want_key (gint mask,
1260                  MSG *msg)
1261 {
1262   return (((msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP)
1263            && !(mask & GDK_KEY_RELEASE_MASK))
1264           ||
1265           ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN)
1266            && !(mask & GDK_KEY_PRESS_MASK)));
1267 }
1268
1269 static gboolean
1270 doesnt_want_char (gint mask,
1271                   MSG *msg)
1272 {
1273   return !(mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK));
1274 }
1275
1276 static gboolean
1277 doesnt_want_button_press (gint mask,
1278                           MSG *msg)
1279 {
1280   return !(mask & GDK_BUTTON_PRESS_MASK);
1281 }
1282
1283 static gboolean
1284 doesnt_want_button_release (gint mask,
1285                             MSG *msg)
1286 {
1287   return !(mask & GDK_BUTTON_RELEASE_MASK);
1288 }
1289
1290 static gboolean
1291 doesnt_want_button_motion (gint mask,
1292                            MSG *msg)
1293 {
1294   return !((mask & GDK_POINTER_MOTION_MASK)
1295            || ((msg->wParam & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON))
1296                && (mask & GDK_BUTTON_MOTION_MASK))
1297            || ((msg->wParam & MK_LBUTTON)
1298                && (mask & GDK_BUTTON1_MOTION_MASK))
1299            || ((msg->wParam & MK_MBUTTON)
1300                && (mask & GDK_BUTTON2_MOTION_MASK))
1301            || ((msg->wParam & MK_RBUTTON)
1302                && (mask & GDK_BUTTON3_MOTION_MASK)));
1303 }
1304
1305 static gboolean
1306 doesnt_want_scroll (gint mask,
1307                     MSG *msg)
1308 {
1309 #if 0
1310   return !(mask & GDK_SCROLL_MASK);
1311 #else
1312   return !(mask & GDK_BUTTON_PRESS_MASK);
1313 #endif
1314 }
1315
1316 static char *
1317 decode_key_lparam (LPARAM lParam)
1318 {
1319   static char buf[100];
1320   char *p = buf;
1321
1322   if (HIWORD (lParam) & KF_UP)
1323     p += sprintf (p, "KF_UP ");
1324   if (HIWORD (lParam) & KF_REPEAT)
1325     p += sprintf (p, "KF_REPEAT ");
1326   if (HIWORD (lParam) & KF_ALTDOWN)
1327     p += sprintf (p, "KF_ALTDOWN ");
1328   if (HIWORD (lParam) & KF_EXTENDED)
1329     p += sprintf (p, "KF_EXTENDED ");
1330   p += sprintf (p, "sc%d rep%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
1331
1332   return buf;
1333 }
1334
1335 static gboolean
1336 gdk_event_translate (GdkEvent *event,
1337                      MSG      *msg,
1338                      gboolean *ret_val_flagp,
1339                      gint     *ret_valp)
1340 {
1341   DWORD pidActWin;
1342   DWORD pidThis;
1343   PAINTSTRUCT paintstruct;
1344   HDC hdc;
1345   HDC bgdc;
1346   HGDIOBJ oldbitmap;
1347   HBRUSH hbr;
1348   COLORREF bg;
1349   RECT rect;
1350   POINT pt;
1351   MINMAXINFO *mmi;
1352   HWND hwnd;
1353   HCURSOR hcursor;
1354
1355   /* Invariant:
1356    * window_impl == GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)
1357    */
1358   GdkWindow *window;
1359   GdkWindowImplWin32 *window_impl;
1360 #define ASSIGN_WINDOW(rhs)                                                 \
1361   (window = rhs,                                                           \
1362    window_impl = (window ? GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl) : NULL))
1363
1364   GdkWindow *orig_window, *new_window;
1365   GdkColormapPrivateWin32 *colormap_private;
1366   GdkPixmap *pixmap;
1367   GdkPixmapImplWin32 *pixmap_impl;
1368
1369   int button;
1370   int i, j;
1371
1372   gchar buf[256];
1373   gboolean return_val;
1374
1375   return_val = FALSE;
1376
1377   if (ret_val_flagp)
1378     *ret_val_flagp = FALSE;
1379
1380   ASSIGN_WINDOW (gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd));
1381   orig_window = window;
1382
1383   event->any.window = window;
1384   event->any.send_event = FALSE;
1385
1386   if (window == NULL)
1387     {
1388       /* Handle WM_QUIT here ? */
1389       if (msg->message == WM_QUIT)
1390         {
1391           GDK_NOTE (EVENTS, g_print ("WM_QUIT: %d\n", msg->wParam));
1392           exit (msg->wParam);
1393         }
1394       else if (msg->message == WM_MOVE
1395                || msg->message == WM_SIZE)
1396         {
1397           /* It's quite normal to get these messages before we have
1398            * had time to register the window in our lookup table, or
1399            * when the window is being destroyed and we already have
1400            * removed it. Repost the same message to our queue so that
1401            * we will get it later when we are prepared.
1402            */
1403           GDK_NOTE(MISC, g_print("gdk_event_translate: %#lx %s posted.\n",
1404                                  (gulong) msg->hwnd,
1405                                  msg->message == WM_MOVE ?
1406                                  "WM_MOVE" : "WM_SIZE"));
1407
1408           PostMessage (msg->hwnd, msg->message,
1409                        msg->wParam, msg->lParam);
1410         }
1411 #ifndef WITHOUT_WM_CREATE
1412       else if (WM_CREATE == msg->message)
1413         {
1414           window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
1415           GDK_WINDOW_HWND (window) = msg->hwnd;
1416           GDK_NOTE (EVENTS, g_print ("gdk_event_translate: created %#x\n",
1417                                      (guint) msg->hwnd));
1418 # if 0
1419           /* This should handle allmost all the other window==NULL cases.
1420            * This code is executed while gdk_window_new is in it's
1421            * CreateWindowEx call.
1422            * Don't insert xid there a second time, if it's done here.
1423            */
1424           gdk_drawable_ref (window);
1425           gdk_win32_handle_table_insert (&GDK_WINDOW_HWND(window), window);
1426 # endif
1427         }
1428       else
1429       {
1430         GDK_NOTE (EVENTS, g_print ("gdk_event_translate: %s for %#x (NULL)\n",
1431                                    gdk_win32_message_name(msg->message),
1432                                    (guint) msg->hwnd));
1433       }
1434 #endif
1435       return FALSE;
1436     }
1437
1438   gdk_drawable_ref (window);
1439
1440   if (!GDK_WINDOW_DESTROYED (window))
1441     {
1442       /* Check for filters for this window */
1443       GdkFilterReturn result;
1444
1445       result = gdk_event_apply_filters
1446         (msg, event, GDK_WINDOW_OBJECT (window)->filters);
1447
1448       if (result != GDK_FILTER_CONTINUE)
1449         {
1450           return_val =  (result == GDK_FILTER_TRANSLATE) ? TRUE : FALSE;
1451           goto done;
1452         }
1453     }
1454
1455   if (msg->message == gdk_selection_notify_msg)
1456     {
1457       GDK_NOTE (EVENTS, g_print ("gdk_selection_notify_msg: %#lx\n",
1458                                  (gulong) msg->hwnd));
1459
1460       event->selection.type = GDK_SELECTION_NOTIFY;
1461       event->selection.window = window;
1462       event->selection.selection = msg->wParam;
1463       event->selection.target = msg->lParam;
1464       event->selection.property = gdk_selection_property;
1465       event->selection.time = msg->time;
1466
1467       return_val = !GDK_WINDOW_DESTROYED (window);
1468
1469       goto done;
1470     }
1471   else if (msg->message == gdk_selection_request_msg)
1472     {
1473       GDK_NOTE (EVENTS, g_print ("gdk_selection_request_msg: %#lx\n",
1474                                  (gulong) msg->hwnd));
1475
1476       event->selection.type = GDK_SELECTION_REQUEST;
1477       event->selection.window = window;
1478       event->selection.selection = gdk_clipboard_atom;
1479       event->selection.target = GDK_TARGET_STRING;
1480       event->selection.property = gdk_selection_property;
1481       event->selection.requestor = (guint32) msg->hwnd;
1482       event->selection.time = msg->time;
1483
1484       return_val = !GDK_WINDOW_DESTROYED (window);
1485
1486       goto done;
1487     }
1488   else if (msg->message == gdk_selection_clear_msg)
1489     {
1490       GDK_NOTE (EVENTS, g_print ("gdk_selection_clear_msg: %#lx\n",
1491                                  (gulong) msg->hwnd));
1492
1493       event->selection.type = GDK_SELECTION_CLEAR;
1494       event->selection.window = window;
1495       event->selection.selection = msg->wParam;
1496       event->selection.time = msg->time;
1497
1498       return_val = !GDK_WINDOW_DESTROYED (window);
1499
1500       goto done;
1501     }
1502   else if (msg->message == msh_mousewheel_msg)
1503     {
1504       GDK_NOTE (EVENTS, g_print ("MSH_MOUSEWHEEL: %#lx %d\n",
1505                                  (gulong) msg->hwnd, msg->wParam));
1506
1507       event->scroll.type = GDK_SCROLL;
1508
1509       /* MSG_MOUSEWHEEL is delivered to the foreground window.  Work
1510        * around that. Also, the position is in screen coordinates, not
1511        * client coordinates as with the button messages.
1512        */
1513       pt.x = LOWORD (msg->lParam);
1514       pt.y = HIWORD (msg->lParam);
1515       if ((hwnd = WindowFromPoint (pt)) == NULL)
1516         goto done;
1517
1518       msg->hwnd = hwnd;
1519       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
1520         goto done;
1521
1522       if (new_window != window)
1523         {
1524           gdk_drawable_unref (window);
1525           ASSIGN_WINDOW (new_window);
1526           gdk_drawable_ref (window);
1527         }
1528
1529       if (GDK_WINDOW_OBJECT (window)->extension_events != 0
1530           && gdk_input_ignore_core)
1531         {
1532           GDK_NOTE (EVENTS, g_print ("...ignored\n"));
1533           goto done;
1534         }
1535
1536       if (!propagate (&window, msg,
1537                       p_grab_window, p_grab_owner_events, p_grab_mask,
1538                       doesnt_want_scroll))
1539         goto done;
1540
1541       ASSIGN_WINDOW (window);
1542
1543       ScreenToClient (msg->hwnd, &pt);
1544       event->button.window = window;
1545       event->scroll.direction = ((int) msg->wParam > 0) ?
1546         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
1547       event->scroll.window = window;
1548       event->scroll.time = msg->time;
1549       event->scroll.x = (gint16) pt.x;
1550       event->scroll.y = (gint16) pt.y;
1551       event->scroll.x_root = (gint16) LOWORD (msg->lParam);
1552       event->scroll.y_root = (gint16) HIWORD (msg->lParam);
1553       event->scroll.state = 0;  /* No state information with MSH_MOUSEWHEEL */
1554       event->scroll.device = gdk_core_pointer;
1555       return_val = !GDK_WINDOW_DESTROYED (window);
1556
1557       goto done;
1558     }
1559   else
1560     {
1561       GList *tmp_list;
1562       GdkFilterReturn result = GDK_FILTER_CONTINUE;
1563
1564       tmp_list = client_filters;
1565       while (tmp_list)
1566         {
1567           GdkClientFilter *filter = tmp_list->data;
1568           if (filter->type == msg->message)
1569             {
1570               GDK_NOTE (EVENTS, g_print ("client filter matched\n"));
1571               event->any.window = window;
1572               result = (*filter->function) (msg, event, filter->data);
1573               switch (result)
1574                 {
1575                 case GDK_FILTER_REMOVE:
1576                   return_val = FALSE;
1577                   break;
1578
1579                 case GDK_FILTER_TRANSLATE:
1580                   return_val = TRUE;
1581                   break;
1582
1583                 case GDK_FILTER_CONTINUE:
1584                   return_val = TRUE;
1585                   event->client.type = GDK_CLIENT_EVENT;
1586                   event->client.window = window;
1587                   event->client.message_type = msg->message;
1588                   event->client.data_format = 0;
1589                   event->client.data.l[0] = msg->wParam;
1590                   event->client.data.l[1] = msg->lParam;
1591                   break;
1592                 }
1593               goto done;
1594             }
1595           tmp_list = tmp_list->next;
1596         }
1597     }
1598
1599   switch (msg->message)
1600     {
1601     case WM_INPUTLANGCHANGE:
1602       GDK_NOTE (EVENTS,
1603                 g_print ("WM_INPUTLANGCHANGE: %#lx  charset %lu locale %lx\n",
1604                          (gulong) msg->hwnd, (gulong) msg->wParam, msg->lParam));
1605       window_impl->input_locale = (HKL) msg->lParam;
1606       TranslateCharsetInfo ((DWORD FAR *) msg->wParam,
1607                             &window_impl->charset_info,
1608                             TCI_SRCCHARSET);
1609       break;
1610
1611     case WM_SYSKEYUP:
1612     case WM_SYSKEYDOWN:
1613       GDK_NOTE (EVENTS,
1614                 g_print ("WM_SYSKEY%s: %#lx  %s %#x %s\n",
1615                          (msg->message == WM_SYSKEYUP ? "UP" : "DOWN"),
1616                          (gulong) msg->hwnd,
1617                          (GetKeyNameText (msg->lParam, buf,
1618                                           sizeof (buf)) > 0 ?
1619                           buf : ""),
1620                          msg->wParam,
1621                          decode_key_lparam (msg->lParam)));
1622
1623       /* Let the system handle Alt-Tab and Alt-Enter */
1624       if (msg->wParam == VK_TAB
1625           || msg->wParam == VK_RETURN
1626           || msg->wParam == VK_F4)
1627         break;
1628       /* If posted without us having keyboard focus, ignore */
1629       if (!(msg->lParam & 0x20000000))
1630         break;
1631 #if 0
1632       /* don't generate events for just the Alt key */
1633       if (msg->wParam == VK_MENU)
1634         break;
1635 #endif
1636       /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
1637       goto keyup_or_down;
1638
1639     case WM_KEYUP:
1640     case WM_KEYDOWN:
1641       GDK_NOTE (EVENTS,
1642                 g_print ("WM_KEY%s: %#lx  %s %#x %s\n",
1643                          (msg->message == WM_KEYUP ? "UP" : "DOWN"),
1644                          (gulong) msg->hwnd,
1645                          (GetKeyNameText (msg->lParam, buf,
1646                                           sizeof (buf)) > 0 ?
1647                           buf : ""),
1648                          msg->wParam,
1649                          decode_key_lparam (msg->lParam)));
1650
1651       ignore_wm_char = TRUE;
1652
1653     keyup_or_down:
1654
1655       event->key.window = window;
1656       switch (msg->wParam)
1657         {
1658         case VK_LBUTTON:
1659           event->key.keyval = GDK_Pointer_Button1; break;
1660         case VK_RBUTTON:
1661           event->key.keyval = GDK_Pointer_Button3; break;
1662         case VK_MBUTTON:
1663           event->key.keyval = GDK_Pointer_Button2; break;
1664         case VK_CANCEL:
1665           event->key.keyval = GDK_Cancel; break;
1666         case VK_BACK:
1667           event->key.keyval = GDK_BackSpace; break;
1668         case VK_TAB:
1669           event->key.keyval = (GetKeyState(VK_SHIFT) < 0 ?
1670             GDK_ISO_Left_Tab : GDK_Tab);
1671           break;
1672         case VK_CLEAR:
1673           event->key.keyval = GDK_Clear; break;
1674         case VK_RETURN:
1675           event->key.keyval = GDK_Return; break;
1676         case VK_SHIFT:
1677           /* Don't let Shift auto-repeat */
1678           if (msg->message == WM_KEYDOWN
1679               && (HIWORD (msg->lParam) & KF_REPEAT))
1680             ignore_wm_char = FALSE;
1681           else
1682             event->key.keyval = GDK_Shift_L;
1683           break;
1684         case VK_CONTROL:
1685           /* And not Control either */
1686           if (msg->message == WM_KEYDOWN
1687               && (HIWORD (msg->lParam) & KF_REPEAT))
1688             ignore_wm_char = FALSE;
1689           else if (HIWORD (msg->lParam) & KF_EXTENDED)
1690             event->key.keyval = GDK_Control_R;
1691           else
1692             event->key.keyval = GDK_Control_L;
1693           break;
1694         case VK_MENU:
1695           /* And not Alt */
1696           if (msg->message == WM_KEYDOWN
1697               && (HIWORD (msg->lParam) & KF_REPEAT))
1698             ignore_wm_char = FALSE;
1699           else if (HIWORD (msg->lParam) & KF_EXTENDED)
1700             {
1701               /* AltGr key comes in as Control+Right Alt */
1702               if (GetKeyState (VK_CONTROL) < 0)
1703                 {
1704                   ignore_wm_char = FALSE;
1705                   is_altgr_key = TRUE;
1706                 }
1707               event->key.keyval = GDK_Alt_R;
1708             }
1709           else
1710             {
1711               event->key.keyval = GDK_Alt_L;
1712               /* This needed in case she types Alt+nnn (on the numpad) */
1713               ignore_wm_char = FALSE;
1714             }
1715           break;
1716         case VK_PAUSE:
1717           event->key.keyval = GDK_Pause; break;
1718         case VK_CAPITAL:
1719           event->key.keyval = GDK_Caps_Lock; break;
1720         case VK_ESCAPE:
1721           event->key.keyval = GDK_Escape; break;
1722         case VK_PRIOR:
1723           event->key.keyval = GDK_Prior; break;
1724         case VK_NEXT:
1725           event->key.keyval = GDK_Next; break;
1726         case VK_END:
1727           event->key.keyval = GDK_End; break;
1728         case VK_HOME:
1729           event->key.keyval = GDK_Home; break;
1730         case VK_LEFT:
1731           event->key.keyval = GDK_Left; break;
1732         case VK_UP:
1733           event->key.keyval = GDK_Up; break;
1734         case VK_RIGHT:
1735           event->key.keyval = GDK_Right; break;
1736         case VK_DOWN:
1737           event->key.keyval = GDK_Down; break;
1738         case VK_SELECT:
1739           event->key.keyval = GDK_Select; break;
1740         case VK_PRINT:
1741           event->key.keyval = GDK_Print; break;
1742         case VK_EXECUTE:
1743           event->key.keyval = GDK_Execute; break;
1744         case VK_INSERT:
1745           event->key.keyval = GDK_Insert; break;
1746         case VK_DELETE:
1747           event->key.keyval = GDK_Delete; break;
1748         case VK_HELP:
1749           event->key.keyval = GDK_Help; break;
1750         case VK_NUMPAD0:
1751         case VK_NUMPAD1:
1752         case VK_NUMPAD2:
1753         case VK_NUMPAD3:
1754         case VK_NUMPAD4:
1755         case VK_NUMPAD5:
1756         case VK_NUMPAD6:
1757         case VK_NUMPAD7:
1758         case VK_NUMPAD8:
1759         case VK_NUMPAD9:
1760           /* Apparently applications work better if we just pass numpad digits
1761            * on as real digits? So wait for the WM_CHAR instead.
1762            */
1763           ignore_wm_char = FALSE;
1764           break;
1765         case VK_MULTIPLY:
1766           event->key.keyval = GDK_KP_Multiply; break;
1767         case VK_ADD:
1768           /* Pass it on as an ASCII plus in WM_CHAR. */
1769           ignore_wm_char = FALSE;
1770           break;
1771         case VK_SEPARATOR:
1772           event->key.keyval = GDK_KP_Separator; break;
1773         case VK_SUBTRACT:
1774           /* Pass it on as an ASCII minus in WM_CHAR. */
1775           ignore_wm_char = FALSE;
1776           break;
1777         case VK_DECIMAL:
1778           /* The keypad decimal key should also be passed on as the decimal
1779            * sign ('.' or ',' depending on the Windows locale settings,
1780            * apparently). So wait for the WM_CHAR here, also.
1781            */
1782           ignore_wm_char = FALSE;
1783           break;
1784         case VK_DIVIDE:
1785           event->key.keyval = GDK_KP_Divide; break;
1786         case VK_F1:
1787           event->key.keyval = GDK_F1; break;
1788         case VK_F2:
1789           event->key.keyval = GDK_F2; break;
1790         case VK_F3:
1791           event->key.keyval = GDK_F3; break;
1792         case VK_F4:
1793           event->key.keyval = GDK_F4; break;
1794         case VK_F5:
1795           event->key.keyval = GDK_F5; break;
1796         case VK_F6:
1797           event->key.keyval = GDK_F6; break;
1798         case VK_F7:
1799           event->key.keyval = GDK_F7; break;
1800         case VK_F8:
1801           event->key.keyval = GDK_F8; break;
1802         case VK_F9:
1803           event->key.keyval = GDK_F9; break;
1804         case VK_F10:
1805           event->key.keyval = GDK_F10; break;
1806         case VK_F11:
1807           event->key.keyval = GDK_F11; break;
1808         case VK_F12:
1809           event->key.keyval = GDK_F12; break;
1810         case VK_F13:
1811           event->key.keyval = GDK_F13; break;
1812         case VK_F14:
1813           event->key.keyval = GDK_F14; break;
1814         case VK_F15:
1815           event->key.keyval = GDK_F15; break;
1816         case VK_F16:
1817           event->key.keyval = GDK_F16; break;
1818         case '0':
1819         case '1':
1820         case '2':
1821         case '3':
1822         case '4':
1823         case '5':
1824         case '6':
1825         case '7':
1826         case '8':
1827         case '9':
1828           if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1829                                 || GetKeyState (VK_MENU) < 0))
1830             /* Control- or Alt-digits won't come in as a WM_CHAR,
1831              * but beware of AltGr-digits, which are used for instance
1832              * on Finnish keyboards.
1833              */
1834             event->key.keyval = GDK_0 + (msg->wParam - '0');
1835           else
1836             ignore_wm_char = FALSE;
1837           break;
1838         case VK_OEM_PLUS:       /* On my Win98, the '+' key comes in
1839                                  * as VK_OEM_PLUS, etc.
1840                                  */
1841         case VK_OEM_COMMA:
1842         case VK_OEM_MINUS:
1843         case VK_OEM_PERIOD:
1844         case VK_OEM_2:
1845         case VK_OEM_4:
1846         case VK_OEM_5:
1847         case VK_OEM_6:
1848           if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1849                                 || GetKeyState (VK_MENU) < 0))
1850             /* Control- or Alt-plus won't come in as WM_CHAR,
1851              * but beware of AltGr-plus which is backslash on
1852              * Finnish keyboards
1853              */
1854             /* All these VK_OEM keycodes happen to be the corresponding ASCII
1855              * char + 0x90
1856              */
1857             event->key.keyval = msg->wParam - 0x90;
1858           else
1859             ignore_wm_char = FALSE;
1860           break;
1861         case VK_OEM_1:
1862           if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1863                                 || GetKeyState (VK_MENU) < 0))
1864             /* ;: on US keyboard */
1865             event->key.keyval = ';';
1866           else
1867             ignore_wm_char = FALSE;
1868           break;
1869         case VK_OEM_3:
1870           if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1871                                 || GetKeyState (VK_MENU) < 0))
1872             /* `~ on US keyboard */
1873             event->key.keyval = '`';
1874           else
1875             ignore_wm_char = FALSE;
1876           break;
1877         case VK_OEM_7:
1878           if (!is_altgr_key && (GetKeyState (VK_CONTROL) < 0
1879                                 || GetKeyState (VK_MENU) < 0))
1880             /* '" on US keyboard */
1881             event->key.keyval = '\'';
1882           else
1883             ignore_wm_char = FALSE;
1884           break;
1885         default:
1886           if (msg->message == WM_SYSKEYDOWN || msg->message == WM_SYSKEYUP)
1887             event->key.keyval = msg->wParam;
1888           else
1889             ignore_wm_char = FALSE;
1890           break;
1891         }
1892
1893       if (!ignore_wm_char)
1894         break;
1895
1896       if (!propagate (&window, msg,
1897                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
1898                       doesnt_want_key))
1899           break;
1900       ASSIGN_WINDOW (window);
1901
1902       is_altgr_key = FALSE;
1903       event->key.type = ((msg->message == WM_KEYDOWN
1904                           || msg->message == WM_SYSKEYDOWN) ?
1905                          GDK_KEY_PRESS : GDK_KEY_RELEASE);
1906       event->key.time = msg->time;
1907       event->key.state = 0;
1908       if (GetKeyState (VK_SHIFT) < 0)
1909         event->key.state |= GDK_SHIFT_MASK;
1910       if (GetKeyState (VK_CAPITAL) & 0x1)
1911         event->key.state |= GDK_LOCK_MASK;
1912       if (GetKeyState (VK_CONTROL) < 0)
1913         event->key.state |= GDK_CONTROL_MASK;
1914       if (msg->wParam != VK_MENU && GetKeyState (VK_MENU) < 0)
1915         event->key.state |= GDK_MOD1_MASK;
1916       event->key.string = NULL;
1917       event->key.length = 0;
1918       return_val = !GDK_WINDOW_DESTROYED (window);
1919       break;
1920
1921     case WM_IME_COMPOSITION:
1922       if (!use_ime_composition)
1923         break;
1924
1925       GDK_NOTE (EVENTS, g_print ("WM_IME_COMPOSITION: %#lx  %#lx\n",
1926                                  (gulong) msg->hwnd, msg->lParam));
1927       if (msg->lParam & GCS_RESULTSTR)
1928         goto wm_char;
1929       break;
1930
1931     case WM_IME_CHAR:
1932       GDK_NOTE (EVENTS,
1933                 g_print ("WM_IME_CHAR: %#lx  bytes: %#.04x\n",
1934                          (gulong) msg->hwnd, msg->wParam));
1935       goto wm_char;
1936
1937     case WM_CHAR:
1938     case WM_SYSCHAR:
1939       GDK_NOTE (EVENTS,
1940                 g_print ("WM_%sCHAR: %#lx  %#x %s %s\n",
1941                          (msg->message == WM_CHAR ? "" : "SYS"),
1942                          (gulong) msg->hwnd, msg->wParam,
1943                          decode_key_lparam (msg->lParam),
1944                          (ignore_wm_char ? "ignored" : "")));
1945
1946       if (ignore_wm_char)
1947         {
1948           ignore_wm_char = FALSE;
1949           break;
1950         }
1951
1952     wm_char:
1953       if (!propagate (&window, msg,
1954                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
1955                       doesnt_want_char))
1956           break;
1957       ASSIGN_WINDOW (window);
1958
1959       event->key.window = window;
1960       return_val = !GDK_WINDOW_DESTROYED (window);
1961
1962       if (return_val && (event->key.window == k_grab_window
1963                          || (window_impl->event_mask & GDK_KEY_RELEASE_MASK)))
1964         {
1965           if (window == k_grab_window
1966               || (window_impl->event_mask & GDK_KEY_PRESS_MASK))
1967             {
1968               /* Append a GDK_KEY_PRESS event to the pushback list
1969                * (from which it will be fetched before the release
1970                * event).
1971                */
1972               GdkEvent *event2 = gdk_event_new ();
1973               build_keypress_event (window_impl, event2, msg);
1974               event2->key.window = window;
1975               gdk_drawable_ref (window);
1976               gdk_event_queue_append (event2);
1977               GDK_NOTE (EVENTS, print_event (event2));
1978             }
1979           /* Return the key release event.  */
1980           build_keyrelease_event (window_impl, event, msg);
1981         }
1982       else if (return_val
1983                && (window_impl->event_mask & GDK_KEY_PRESS_MASK))
1984         {
1985           /* Return just the key press event. */
1986           build_keypress_event (window_impl, event, msg);
1987         }
1988       else
1989         return_val = FALSE;
1990
1991 #if 0 /* Don't reset is_AltGr_key here. Othewise we can't type several
1992        * AltGr-accessed chars while keeping the AltGr pressed down
1993        * all the time.
1994        */
1995       is_AltGr_key = FALSE;
1996 #endif
1997       break;
1998
1999     case WM_LBUTTONDOWN:
2000       button = 1;
2001       goto buttondown0;
2002     case WM_MBUTTONDOWN:
2003       button = 2;
2004       goto buttondown0;
2005     case WM_RBUTTONDOWN:
2006       button = 3;
2007
2008     buttondown0:
2009       GDK_NOTE (EVENTS,
2010                 g_print ("WM_%cBUTTONDOWN: %#lx  (%d,%d)\n",
2011                          " LMR"[button],
2012                          (gulong) msg->hwnd,
2013                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2014
2015       if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2016           && gdk_input_ignore_core)
2017         {
2018           GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2019           break;
2020         }
2021
2022       if (window != current_window)
2023         synthesize_crossing_events (window, msg);
2024
2025       event->button.type = GDK_BUTTON_PRESS;
2026       if (!propagate (&window, msg,
2027                       p_grab_window, p_grab_owner_events, p_grab_mask,
2028                       doesnt_want_button_press))
2029           break;
2030       ASSIGN_WINDOW (window);
2031
2032       event->button.window = window;
2033
2034       /* Emulate X11's automatic active grab */
2035       if (!p_grab_window)
2036         {
2037           /* No explicit active grab, let's start one automatically */
2038           gint owner_events = window_impl->event_mask
2039             & (GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK);
2040
2041           GDK_NOTE (EVENTS, g_print ("...automatic grab started\n"));
2042           gdk_pointer_grab (window,
2043                             owner_events,
2044                             window_impl->event_mask,
2045                             NULL, NULL, 0);
2046           p_grab_automatic = TRUE;
2047         }
2048
2049       event->button.time = msg->time;
2050       if (window != orig_window)
2051         translate_mouse_coords (orig_window, window, msg);
2052       event->button.x = current_x = (gint16) LOWORD (msg->lParam);
2053       event->button.y = current_y = (gint16) HIWORD (msg->lParam);
2054       event->button.x_root = msg->pt.x;
2055       event->button.y_root = msg->pt.y;
2056       event->button.axes = NULL;
2057       event->button.state = build_pointer_event_state (msg);
2058       event->button.button = button;
2059       event->button.device = gdk_core_pointer;
2060
2061       gdk_event_button_generate (event);
2062
2063       return_val = !GDK_WINDOW_DESTROYED (window);
2064       break;
2065
2066     case WM_LBUTTONUP:
2067       button = 1;
2068       goto buttonup0;
2069     case WM_MBUTTONUP:
2070       button = 2;
2071       goto buttonup0;
2072     case WM_RBUTTONUP:
2073       button = 3;
2074
2075     buttonup0:
2076       GDK_NOTE (EVENTS,
2077                 g_print ("WM_%cBUTTONUP: %#lx  (%d,%d)\n",
2078                          " LMR"[button],
2079                          (gulong) msg->hwnd,
2080                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2081
2082       if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2083           && gdk_input_ignore_core)
2084         {
2085           GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2086           break;
2087         }
2088
2089       if (window != current_window)
2090         synthesize_crossing_events (window, msg);
2091
2092       event->button.type = GDK_BUTTON_RELEASE;
2093       if (!propagate (&window, msg,
2094                       p_grab_window, p_grab_owner_events, p_grab_mask,
2095                       doesnt_want_button_release))
2096           goto maybe_ungrab;
2097       ASSIGN_WINDOW (window);
2098
2099       event->button.window = window;
2100       event->button.time = msg->time;
2101       if (window != orig_window)
2102         translate_mouse_coords (orig_window, window, msg);
2103       event->button.x = (gint16) LOWORD (msg->lParam);
2104       event->button.y = (gint16) HIWORD (msg->lParam);
2105       event->button.x_root = msg->pt.x;
2106       event->button.y_root = msg->pt.y;
2107       event->button.axes = NULL;
2108       event->button.state = build_pointer_event_state (msg);
2109       event->button.button = button;
2110       event->button.device = gdk_core_pointer;
2111
2112       return_val = !GDK_WINDOW_DESTROYED (window);
2113
2114     maybe_ungrab:
2115       if (p_grab_window != NULL
2116           && p_grab_automatic
2117           && (event->button.state & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK)) == 0)
2118         gdk_pointer_ungrab (0);
2119       break;
2120
2121     case WM_MOUSEMOVE:
2122       GDK_NOTE (EVENTS,
2123                 g_print ("WM_MOUSEMOVE: %#lx  %#x (%d,%d)\n",
2124                          (gulong) msg->hwnd, msg->wParam,
2125                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2126
2127       /* If we haven't moved, don't create any event.
2128        * Windows sends WM_MOUSEMOVE messages after button presses
2129        * even if the mouse doesn't move. This disturbs gtk.
2130        */
2131       if (window == current_window
2132           && LOWORD (msg->lParam) == current_x
2133           && HIWORD (msg->lParam) == current_y)
2134         break;
2135
2136       /* HB: only process mouse move messages if we own the active window. */
2137       GetWindowThreadProcessId(GetActiveWindow(), &pidActWin);
2138       GetWindowThreadProcessId(msg->hwnd, &pidThis);
2139       if (pidActWin != pidThis)
2140         break;
2141
2142       if (window != current_window)
2143         synthesize_crossing_events (window, msg);
2144
2145       if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2146           && gdk_input_ignore_core)
2147         {
2148           GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2149           break;
2150         }
2151
2152       event->motion.type = GDK_MOTION_NOTIFY;
2153       if (!propagate (&window, msg,
2154                       p_grab_window, p_grab_owner_events, p_grab_mask,
2155                       doesnt_want_button_motion))
2156           break;
2157       ASSIGN_WINDOW (window);
2158
2159       event->motion.window = window;
2160       event->motion.time = msg->time;
2161       if (window != orig_window)
2162         translate_mouse_coords (orig_window, window, msg);
2163       event->motion.x = current_x = (gint16) LOWORD (msg->lParam);
2164       event->motion.y = current_y = (gint16) HIWORD (msg->lParam);
2165       event->motion.x_root = current_x_root = msg->pt.x;
2166       event->motion.y_root = current_y_root = msg->pt.y;
2167       event->motion.axes = NULL;
2168       event->motion.state = build_pointer_event_state (msg);
2169       event->motion.is_hint = FALSE;
2170       event->motion.device = gdk_core_pointer;
2171
2172       return_val = !GDK_WINDOW_DESTROYED (window);
2173       break;
2174
2175     case WM_NCMOUSEMOVE:
2176       GDK_NOTE (EVENTS,
2177                 g_print ("WM_NCMOUSEMOVE: %#lx  x,y: %d %d\n",
2178                          (gulong) msg->hwnd,
2179                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2180       if (track_mouse_event == NULL
2181           && current_window != NULL
2182           && (GDK_WINDOW_IMPL_WIN32 (GDK_WINDOW_OBJECT (current_window)->impl)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2183         {
2184           GDK_NOTE (EVENTS, g_print ("...synthesizing LEAVE_NOTIFY event\n"));
2185
2186           event->crossing.type = GDK_LEAVE_NOTIFY;
2187           event->crossing.window = current_window;
2188           event->crossing.subwindow = NULL;
2189           event->crossing.time = msg->time;
2190           event->crossing.x = current_x;
2191           event->crossing.y = current_y;
2192           event->crossing.x_root = current_x_root;
2193           event->crossing.y_root = current_y_root;
2194           event->crossing.mode = GDK_CROSSING_NORMAL;
2195           event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2196
2197           event->crossing.focus = TRUE; /* ??? */
2198           event->crossing.state = 0; /* ??? */
2199           return_val = TRUE;
2200         }
2201
2202       if (current_window)
2203         {
2204           gdk_drawable_unref (current_window);
2205           current_window = NULL;
2206         }
2207
2208       break;
2209
2210     case WM_MOUSEWHEEL:
2211       GDK_NOTE (EVENTS, g_print ("WM_MOUSEWHEEL: %#lx %d\n",
2212                                  (gulong) msg->hwnd, HIWORD (msg->wParam)));
2213
2214       event->scroll.type = GDK_SCROLL;
2215
2216       /* WM_MOUSEWHEEL is delivered to the focus window Work around
2217        * that. Also, the position is in screen coordinates, not client
2218        * coordinates as with the button messages. I love the
2219        * consistency of Windows.
2220        */
2221       pt.x = LOWORD (msg->lParam);
2222       pt.y = HIWORD (msg->lParam);
2223       if ((hwnd = WindowFromPoint (pt)) == NULL)
2224         break;
2225
2226       msg->hwnd = hwnd;
2227       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2228         break;
2229
2230       if (new_window != window)
2231         {
2232           gdk_drawable_unref (window);
2233           ASSIGN_WINDOW (new_window);
2234           gdk_drawable_ref (window);
2235         }
2236
2237       if (GDK_WINDOW_OBJECT (window)->extension_events != 0
2238           && gdk_input_ignore_core)
2239         {
2240           GDK_NOTE (EVENTS, g_print ("...ignored\n"));
2241           break;
2242         }
2243
2244       if (!propagate (&window, msg,
2245                       p_grab_window, p_grab_owner_events, p_grab_mask,
2246                       doesnt_want_scroll))
2247         break;
2248
2249       ASSIGN_WINDOW (window);
2250
2251       ScreenToClient (msg->hwnd, &pt);
2252       event->button.window = window;
2253       event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2254         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2255       event->scroll.window = window;
2256       event->scroll.time = msg->time;
2257       event->scroll.x = (gint16) pt.x;
2258       event->scroll.y = (gint16) pt.y;
2259       event->scroll.x_root = (gint16) LOWORD (msg->lParam);
2260       event->scroll.y_root = (gint16) HIWORD (msg->lParam);
2261       event->scroll.state = build_pointer_event_state (msg);
2262       event->scroll.device = gdk_core_pointer;
2263       return_val = !GDK_WINDOW_DESTROYED (window);
2264
2265       break;
2266
2267 #ifdef USE_TRACKMOUSEEVENT
2268     case WM_MOUSELEAVE:
2269       GDK_NOTE (EVENTS, g_print ("WM_MOUSELEAVE: %#lx\n", (gulong) msg->hwnd));
2270
2271       if (!(window_impl->event_mask & GDK_LEAVE_NOTIFY_MASK))
2272         break;
2273
2274       event->crossing.type = GDK_LEAVE_NOTIFY;
2275       event->crossing.window = window;
2276       event->crossing.subwindow = NULL;
2277       event->crossing.time = msg->time;
2278       event->crossing.x = current_x;
2279       event->crossing.y = current_y;
2280       event->crossing.x_root = current_xroot;
2281       event->crossing.y_root = current_yroot;
2282       event->crossing.mode = GDK_CROSSING_NORMAL;
2283       if (current_window
2284           && IsChild (GDK_WINDOW_HWND (current_window), GDK_WINDOW_HWND (window)))
2285         event->crossing.detail = GDK_NOTIFY_INFERIOR;
2286       else if (current_window
2287                && IsChild (GDK_WINDOW_HWND (window), GDK_WINDOW_HWND (current_window)))
2288         event->crossing.detail = GDK_NOTIFY_ANCESTOR;
2289       else
2290         event->crossing.detail = GDK_NOTIFY_NONLINEAR;
2291
2292       event->crossing.focus = TRUE; /* ??? */
2293       event->crossing.state = 0; /* ??? */
2294
2295       if (current_window)
2296         {
2297           gdk_drawable_unref (current_window);
2298           current_window = NULL;
2299         }
2300
2301       return_val = !GDK_WINDOW_DESTROYED (window);
2302       break;
2303 #endif
2304
2305     case WM_SETFOCUS:
2306     case WM_KILLFOCUS:
2307       GDK_NOTE (EVENTS, g_print ("WM_%sFOCUS: %#lx\n",
2308                                  (msg->message == WM_SETFOCUS ?
2309                                   "SET" : "KILL"),
2310                                  (gulong) msg->hwnd));
2311
2312       if (!(window_impl->event_mask & GDK_FOCUS_CHANGE_MASK))
2313         break;
2314
2315       event->focus_change.type = GDK_FOCUS_CHANGE;
2316       event->focus_change.window = window;
2317       event->focus_change.in = (msg->message == WM_SETFOCUS);
2318       return_val = !GDK_WINDOW_DESTROYED (window);
2319       break;
2320
2321     case WM_ERASEBKGND:
2322       GDK_NOTE (EVENTS, g_print ("WM_ERASEBKGND: %#lx  dc %#x\n",
2323                                  (gulong) msg->hwnd, msg->wParam));
2324
2325       if (GDK_WINDOW_DESTROYED (window))
2326         break;
2327
2328       colormap_private = (GdkColormapPrivateWin32 *) GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap;
2329       hdc = (HDC) msg->wParam;
2330       if (colormap_private && colormap_private->xcolormap->rc_palette)
2331         {
2332           int k;
2333
2334           if (SelectPalette (hdc,  colormap_private->xcolormap->palette,
2335                              FALSE) == NULL)
2336             WIN32_GDI_FAILED ("SelectPalette");
2337           if ((k = RealizePalette (hdc)) == GDI_ERROR)
2338             WIN32_GDI_FAILED ("RealizePalette");
2339 #if 0
2340           g_print ("WM_ERASEBKGND: selected %#x, realized %d colors\n",
2341                    colormap_private->xcolormap->palette, k);
2342 #endif
2343         }
2344       *ret_val_flagp = TRUE;
2345       *ret_valp = 1;
2346
2347       if (GDK_WINDOW_OBJECT (window)->input_only)
2348         break;
2349
2350       if (GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2351         {
2352           /* If this window should have the same background as the
2353            * parent, fetch the parent. (And if the same goes for
2354            * the parent, fetch the grandparent, etc.)
2355            */
2356           while (window && GDK_WINDOW_OBJECT (window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
2357             {
2358               gdk_drawable_unref (window);
2359               ASSIGN_WINDOW (GDK_WINDOW (GDK_WINDOW_OBJECT (window)->parent));
2360               gdk_drawable_ref (window);
2361             }
2362         }
2363
2364       if (GDK_WINDOW_OBJECT (window)->bg_pixmap == NULL)
2365         {
2366           bg = gdk_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (GDK_WINDOW_OBJECT (window)->impl)->colormap,
2367                                    GDK_WINDOW_OBJECT (window)->bg_color.pixel);
2368
2369           GetClipBox (hdc, &rect);
2370           GDK_NOTE (EVENTS,
2371                     g_print ("...%ldx%ld@+%ld+%ld BG_PIXEL %.06lx\n",
2372                              rect.right - rect.left,
2373                              rect.bottom - rect.top,
2374                              rect.left, rect.top,
2375                              (gulong) bg));
2376           hbr = CreateSolidBrush (bg);
2377 #if 0
2378           g_print ("...CreateSolidBrush (%.08x) = %.08x\n", bg, hbr);
2379 #endif
2380           if (!FillRect (hdc, &rect, hbr))
2381             WIN32_GDI_FAILED ("FillRect");
2382           DeleteObject (hbr);
2383         }
2384       else if (GDK_WINDOW_OBJECT (window)->bg_pixmap != NULL &&
2385                GDK_WINDOW_OBJECT (window)->bg_pixmap != GDK_NO_BG)
2386         {
2387           pixmap = GDK_WINDOW_OBJECT (window)->bg_pixmap;
2388           pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (pixmap);
2389           GetClipBox (hdc, &rect);
2390
2391           if (pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
2392             {
2393               GDK_NOTE (EVENTS, g_print ("...small pixmap, using brush\n"));
2394               hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap));
2395               if (!FillRect (hdc, &rect, hbr))
2396                 WIN32_GDI_FAILED ("FillRect");
2397               DeleteObject (hbr);
2398             }
2399           else
2400             {
2401               GDK_NOTE (EVENTS,
2402                         g_print ("...blitting pixmap %#lx (%dx%d) "
2403                                  "all over the place,\n"
2404                                  "...clip box = %ldx%ld@+%ld+%ld\n",
2405                                  (gulong) GDK_PIXMAP_HBITMAP (pixmap),
2406                                  pixmap_impl->width, pixmap_impl->height,
2407                                  rect.right - rect.left, rect.bottom - rect.top,
2408                                  rect.left, rect.top));
2409
2410               if (!(bgdc = CreateCompatibleDC (hdc)))
2411                 {
2412                   WIN32_GDI_FAILED ("CreateCompatibleDC");
2413                   break;
2414                 }
2415               if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
2416                 {
2417                   WIN32_GDI_FAILED ("SelectObject");
2418                   DeleteDC (bgdc);
2419                   break;
2420                 }
2421               i = 0;
2422               while (i < rect.right)
2423                 {
2424                   j = 0;
2425                   while (j < rect.bottom)
2426                     {
2427                       if (i + pixmap_impl->width >= rect.left
2428                           && j + pixmap_impl->height >= rect.top)
2429                         {
2430                           if (!BitBlt (hdc, i, j,
2431                                        pixmap_impl->width, pixmap_impl->height,
2432                                        bgdc, 0, 0, SRCCOPY))
2433                             {
2434                               WIN32_GDI_FAILED ("BitBlt");
2435                               goto loopexit;
2436                             }
2437                         }
2438                       j += pixmap_impl->height;
2439                     }
2440                   i += pixmap_impl->width;
2441                 }
2442             loopexit:
2443               SelectObject (bgdc, oldbitmap);
2444               DeleteDC (bgdc);
2445             }
2446         }
2447       else
2448         {
2449           GDK_NOTE (EVENTS, g_print ("...BLACK_BRUSH (?)\n"));
2450           hbr = GetStockObject (BLACK_BRUSH);
2451           GetClipBox (hdc, &rect);
2452           if (!FillRect (hdc, &rect, hbr))
2453             WIN32_GDI_FAILED ("FillRect");
2454         }
2455       break;
2456
2457     case WM_PAINT:
2458       if (!GetUpdateRect(msg->hwnd, NULL, FALSE))
2459         {
2460           GDK_NOTE (EVENTS, g_print ("WM_PAINT: %#lx no update rect\n",
2461                                      (gulong) msg->hwnd));
2462           break;
2463         }
2464
2465       /* HB: don't generate GDK_EXPOSE events for InputOnly
2466        * windows -> backing store now works!
2467        */
2468       if (GDK_WINDOW_OBJECT (window)->input_only)
2469         break;
2470
2471       hdc = BeginPaint (msg->hwnd, &paintstruct);
2472
2473       GDK_NOTE (EVENTS,
2474                 g_print ("WM_PAINT: %#lx  %ldx%ld@+%ld+%ld %s dc %#lx\n",
2475                          (gulong) msg->hwnd,
2476                          paintstruct.rcPaint.right - paintstruct.rcPaint.left,
2477                          paintstruct.rcPaint.bottom - paintstruct.rcPaint.top,
2478                          paintstruct.rcPaint.left, paintstruct.rcPaint.top,
2479                          (paintstruct.fErase ? "erase" : ""),
2480                          (gulong) hdc));
2481
2482       EndPaint (msg->hwnd, &paintstruct);
2483
2484       if (!(window_impl->event_mask & GDK_EXPOSURE_MASK))
2485         break;
2486
2487       if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left)
2488           || (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
2489         break;
2490
2491       event->expose.type = GDK_EXPOSE;
2492       event->expose.window = window;
2493       event->expose.area.x = paintstruct.rcPaint.left;
2494       event->expose.area.y = paintstruct.rcPaint.top;
2495       event->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2496       event->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2497       event->expose.count = 0;
2498
2499       return_val = !GDK_WINDOW_DESTROYED (window);
2500       if (return_val)
2501         {
2502           GList *list = gdk_queued_events;
2503           while (list != NULL )
2504             {
2505               if ((((GdkEvent *)list->data)->any.type == GDK_EXPOSE) &&
2506                   (((GdkEvent *)list->data)->any.window == window) &&
2507                   !(((GdkEventPrivate *)list->data)->flags & GDK_EVENT_PENDING))
2508                 ((GdkEvent *)list->data)->expose.count++;
2509
2510               list = list->next;
2511             }
2512         }
2513       break;
2514
2515     case WM_SETCURSOR:
2516       GDK_NOTE (EVENTS, g_print ("WM_SETCURSOR: %#lx %#x %#x\n",
2517                                  (gulong) msg->hwnd,
2518                                  LOWORD (msg->lParam), HIWORD (msg->lParam)));
2519
2520       if (LOWORD (msg->lParam) != HTCLIENT)
2521         break;
2522
2523       if (p_grab_window != NULL && p_grab_cursor != NULL)
2524         hcursor = p_grab_cursor;
2525       else if (!GDK_WINDOW_DESTROYED (window))
2526         hcursor = window_impl->hcursor;
2527       else
2528         hcursor = NULL;
2529
2530       if (hcursor != NULL)
2531         {
2532           GDK_NOTE (EVENTS, g_print ("...SetCursor(%#lx)\n", (gulong) hcursor));
2533           SetCursor (hcursor);
2534           *ret_val_flagp = TRUE;
2535           *ret_valp = TRUE;
2536         }
2537       break;
2538
2539     case WM_SHOWWINDOW:
2540       GDK_NOTE (EVENTS, g_print ("WM_SHOWWINDOW: %#lx  %d\n",
2541                                  (gulong) msg->hwnd,
2542                                  msg->wParam));
2543
2544       if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2545         break;
2546
2547       event->any.type = (msg->wParam ? GDK_MAP : GDK_UNMAP);
2548       event->any.window = window;
2549
2550       if (event->any.type == GDK_UNMAP
2551           && p_grab_window == window)
2552         gdk_pointer_ungrab (msg->time);
2553
2554       if (event->any.type == GDK_UNMAP
2555           && k_grab_window == window)
2556         gdk_keyboard_ungrab (msg->time);
2557
2558       return_val = !GDK_WINDOW_DESTROYED (window);
2559       break;
2560
2561     case WM_SIZE:
2562       GDK_NOTE (EVENTS,
2563                 g_print ("WM_SIZE: %#lx  %s %dx%d\n",
2564                          (gulong) msg->hwnd,
2565                          (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
2566                           (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
2567                            (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
2568                             (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
2569                              (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
2570                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2571
2572       if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2573         break;
2574
2575       if (msg->wParam == SIZE_MINIMIZED)
2576         {
2577           event->any.type = GDK_UNMAP;
2578           event->any.window = window;
2579
2580           if (p_grab_window == window)
2581             gdk_pointer_ungrab (msg->time);
2582
2583           if (k_grab_window == window)
2584             gdk_keyboard_ungrab (msg->time);
2585
2586           return_val = !GDK_WINDOW_DESTROYED (window);
2587         }
2588       else if ((msg->wParam == SIZE_RESTORED
2589                 || msg->wParam == SIZE_MAXIMIZED)
2590 #if 1
2591                && GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2592 #endif
2593                                                                  )
2594         {
2595           if (LOWORD (msg->lParam) == 0)
2596             break;
2597
2598           event->configure.type = GDK_CONFIGURE;
2599           event->configure.window = window;
2600           pt.x = 0;
2601           pt.y = 0;
2602           ClientToScreen (msg->hwnd, &pt);
2603           event->configure.x = pt.x;
2604           event->configure.y = pt.y;
2605           event->configure.width = LOWORD (msg->lParam);
2606           event->configure.height = HIWORD (msg->lParam);
2607           GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2608           GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2609           window_impl->width = event->configure.width;
2610           window_impl->height = event->configure.height;
2611
2612           if (GDK_WINDOW_OBJECT (window)->resize_count > 1)
2613             GDK_WINDOW_OBJECT (window)->resize_count -= 1;
2614
2615           return_val = !GDK_WINDOW_DESTROYED (window);
2616           if (return_val
2617               && GDK_WINDOW_OBJECT (window)->extension_events != 0)
2618             _gdk_input_configure_event (&event->configure, window);
2619         }
2620       break;
2621
2622     case WM_GETMINMAXINFO:
2623       GDK_NOTE (EVENTS, g_print ("WM_GETMINMAXINFO: %#lx\n", (gulong) msg->hwnd));
2624
2625       mmi = (MINMAXINFO*) msg->lParam;
2626       if (window_impl->hint_flags & GDK_HINT_MIN_SIZE)
2627         {
2628           mmi->ptMinTrackSize.x = window_impl->hint_min_width;
2629           mmi->ptMinTrackSize.y = window_impl->hint_min_height;
2630         }
2631       if (window_impl->hint_flags & GDK_HINT_MAX_SIZE)
2632         {
2633           mmi->ptMaxTrackSize.x = window_impl->hint_max_width;
2634           mmi->ptMaxTrackSize.y = window_impl->hint_max_height;
2635
2636           mmi->ptMaxSize.x = window_impl->hint_max_width;
2637           mmi->ptMaxSize.y = window_impl->hint_max_height;
2638         }
2639       break;
2640
2641     case WM_MOVE:
2642       GDK_NOTE (EVENTS, g_print ("WM_MOVE: %#lx  (%d,%d)\n",
2643                                  (gulong) msg->hwnd,
2644                                  LOWORD (msg->lParam), HIWORD (msg->lParam)));
2645
2646       if (!(window_impl->event_mask & GDK_STRUCTURE_MASK))
2647         break;
2648
2649       if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD
2650           && !IsIconic(msg->hwnd)
2651           && IsWindowVisible(msg->hwnd))
2652         {
2653           event->configure.type = GDK_CONFIGURE;
2654           event->configure.window = window;
2655           event->configure.x = LOWORD (msg->lParam);
2656           event->configure.y = HIWORD (msg->lParam);
2657           GetClientRect (msg->hwnd, &rect);
2658           event->configure.width = rect.right;
2659           event->configure.height = rect.bottom;
2660           GDK_WINDOW_OBJECT (window)->x = event->configure.x;
2661           GDK_WINDOW_OBJECT (window)->y = event->configure.y;
2662           window_impl->width = event->configure.width;
2663           window_impl->height = event->configure.height;
2664
2665           return_val = !GDK_WINDOW_DESTROYED (window);
2666         }
2667       break;
2668
2669     case WM_CLOSE:
2670       GDK_NOTE (EVENTS, g_print ("WM_CLOSE: %#lx\n", (gulong) msg->hwnd));
2671
2672       event->any.type = GDK_DELETE;
2673       event->any.window = window;
2674
2675       return_val = !GDK_WINDOW_DESTROYED (window);
2676       break;
2677
2678 #if 0
2679     /* No, don't use delayed rendering after all. It works only if the
2680      * delayed SetClipboardData is called from the WindowProc, it
2681      * seems. (The #else part below is test code for that. It succeeds
2682      * in setting the clipboard data. But if I call SetClipboardData
2683      * in gdk_property_change (as a consequence of the
2684      * GDK_SELECTION_REQUEST event), it fails.  I deduce that this is
2685      * because delayed rendering requires that SetClipboardData is
2686      * called in the window procedure.)
2687      */
2688     case WM_RENDERFORMAT:
2689     case WM_RENDERALLFORMATS:
2690       flag = FALSE;
2691       GDK_NOTE (EVENTS, flag = TRUE);
2692       if (flag)
2693         g_print ("WM_%s: %#lx %#x (%s)\n",
2694                  (msg->message == WM_RENDERFORMAT ? "RENDERFORMAT" :
2695                   "RENDERALLFORMATS"),
2696                  (gulong) msg->hwnd,
2697                  msg->wParam,
2698                  (msg->wParam == CF_TEXT ? "CF_TEXT" :
2699                   (msg->wParam == CF_DIB ? "CF_DIB" :
2700                    (msg->wParam == CF_UNICODETEXT ? "CF_UNICODETEXT" :
2701                     (GetClipboardFormatName (msg->wParam, buf, sizeof (buf)), buf)))));
2702
2703 #if 0
2704       event->selection.type = GDK_SELECTION_REQUEST;
2705       event->selection.window = window;
2706       event->selection.selection = gdk_clipboard_atom;
2707       if (msg->wParam == CF_TEXT)
2708         event->selection.target = GDK_TARGET_STRING;
2709       else
2710         {
2711           GetClipboardFormatName (msg->wParam, buf, sizeof (buf));
2712           event->selection.target = gdk_atom_intern (buf, FALSE);
2713         }
2714       event->selection.property = gdk_selection_property;
2715       event->selection.requestor = (guint32) msg->hwnd;
2716       event->selection.time = msg->time;
2717       return_val = !GDK_WINDOW_DESTROYED (window);
2718 #else
2719       /* Test code, to see if SetClipboardData works when called from
2720        * the window procedure.
2721        */
2722       {
2723         HGLOBAL hdata = GlobalAlloc (GMEM_MOVEABLE|GMEM_DDESHARE, 10);
2724         char *ptr = GlobalLock (hdata);
2725         strcpy (ptr, "Huhhaa");
2726         GlobalUnlock (hdata);
2727         if (!SetClipboardData (CF_TEXT, hdata))
2728           WIN32_API_FAILED ("SetClipboardData");
2729       }
2730       *ret_valp = 0;
2731       *ret_val_flagp = TRUE;
2732       return_val = FALSE;
2733 #endif
2734       break;
2735 #endif /* No delayed rendering */
2736
2737     case WM_DESTROY:
2738       GDK_NOTE (EVENTS, g_print ("WM_DESTROY: %#lx\n", (gulong) msg->hwnd));
2739
2740       event->any.type = GDK_DESTROY;
2741       event->any.window = window;
2742       if (window != NULL && window == current_window)
2743         {
2744           gdk_drawable_unref (current_window);
2745           current_window = NULL;
2746         }
2747
2748       if (p_grab_window == window)
2749         gdk_pointer_ungrab (msg->time);
2750
2751       if (k_grab_window == window)
2752         gdk_keyboard_ungrab (msg->time);
2753
2754       return_val = window != NULL && !GDK_WINDOW_DESTROYED (window);
2755
2756       if ((window != NULL) && (gdk_root_window != msg->hwnd))
2757         gdk_window_destroy_notify (window);
2758
2759       break;
2760
2761 #ifdef HAVE_WINTAB
2762       /* Handle WINTAB events here, as we know that gdkinput.c will
2763        * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
2764        * constants as case labels.
2765        */
2766     case WT_PACKET:
2767       GDK_NOTE (EVENTS, g_print ("WT_PACKET: %#lx %d %#lx\n",
2768                                  (gulong) msg->hwnd,
2769                                  msg->wParam, msg->lParam));
2770       goto wintab;
2771
2772     case WT_CSRCHANGE:
2773       GDK_NOTE (EVENTS, g_print ("WT_CSRCHANGE: %#lx %d %#lx\n",
2774                                  (gulong) msg->hwnd,
2775                                  msg->wParam, msg->lParam));
2776       goto wintab;
2777
2778     case WT_PROXIMITY:
2779       GDK_NOTE (EVENTS, g_print ("WT_PROXIMITY: %#lx %#x %d %d\n",
2780                                  (gulong) msg->hwnd, msg->wParam,
2781                                  LOWORD (msg->lParam),
2782                                  HIWORD (msg->lParam)));
2783       /* Fall through */
2784     wintab:
2785       event->any.window = window;
2786       return_val = _gdk_input_other_event(event, msg, window);
2787       break;
2788 #endif
2789
2790     default:
2791       GDK_NOTE (EVENTS, g_print ("%s: %#lx %#x %#lx\n",
2792                                  gdk_win32_message_name (msg->message),
2793                                  (gulong) msg->hwnd,
2794                                  msg->wParam, msg->lParam));
2795     }
2796
2797 done:
2798
2799   if (return_val)
2800     {
2801       if (event->any.window)
2802         gdk_drawable_ref (event->any.window);
2803       if (((event->any.type == GDK_ENTER_NOTIFY) ||
2804            (event->any.type == GDK_LEAVE_NOTIFY)) &&
2805           (event->crossing.subwindow != NULL))
2806         gdk_drawable_ref (event->crossing.subwindow);
2807
2808       GDK_NOTE (EVENTS, print_event (event));
2809     }
2810   else
2811     {
2812       /* Mark this event as having no resources to be freed */
2813       event->any.window = NULL;
2814       event->any.type = GDK_NOTHING;
2815     }
2816
2817   if (window)
2818     gdk_drawable_unref (window);
2819
2820   return return_val;
2821 }
2822
2823 void
2824 gdk_events_queue (void)
2825 {
2826   MSG msg;
2827
2828   while (!gdk_event_queue_find_first ()
2829          && PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
2830     {
2831       GDK_NOTE (EVENTS, g_print ("PeekMessage: %#lx %s\n",
2832                                  (gulong) msg.hwnd, gdk_win32_message_name (msg.message)));
2833
2834       if (active_imm_msgpump_owner == NULL
2835           || (active_imm_msgpump_owner->lpVtbl->OnTranslateMessage) (active_imm_msgpump_owner, &msg) != S_OK)
2836         TranslateMessage (&msg);
2837
2838       DispatchMessage (&msg);
2839     }
2840 }
2841
2842 static gboolean
2843 gdk_event_prepare (GSource *source,
2844                    gint    *timeout)
2845 {
2846   MSG msg;
2847   gboolean retval;
2848
2849   GDK_THREADS_ENTER ();
2850
2851   *timeout = -1;
2852
2853   retval = (gdk_event_queue_find_first () != NULL)
2854               || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
2855
2856   GDK_THREADS_LEAVE ();
2857
2858   return retval;
2859 }
2860
2861 static gboolean
2862 gdk_event_check (GSource *source)
2863 {
2864   MSG msg;
2865   gboolean retval;
2866
2867   GDK_THREADS_ENTER ();
2868
2869   if (event_poll_fd.revents & G_IO_IN)
2870     retval = (gdk_event_queue_find_first () != NULL)
2871               || PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE);
2872   else
2873     retval = FALSE;
2874
2875   GDK_THREADS_LEAVE ();
2876
2877   return retval;
2878 }
2879
2880 static gboolean
2881 gdk_event_dispatch (GSource     *source,
2882                     GSourceFunc  callback,
2883                     gpointer     user_data)
2884 {
2885   GdkEvent *event;
2886
2887   GDK_THREADS_ENTER ();
2888
2889   gdk_events_queue();
2890   event = gdk_event_unqueue();
2891
2892   if (event)
2893     {
2894       if (gdk_event_func)
2895         (*gdk_event_func) (event, gdk_event_data);
2896
2897       gdk_event_free (event);
2898     }
2899
2900   GDK_THREADS_LEAVE ();
2901
2902   return TRUE;
2903 }
2904
2905 /* Sends a ClientMessage to all toplevel client windows */
2906 gboolean
2907 gdk_event_send_client_message (GdkEvent *event, guint32 xid)
2908 {
2909   /* XXX */
2910   return FALSE;
2911 }
2912
2913 void
2914 gdk_event_send_clientmessage_toall (GdkEvent *event)
2915 {
2916   /* XXX */
2917 }
2918
2919 void
2920 gdk_flush (void)
2921 {
2922   GdiFlush ();
2923 }
2924
2925 #ifdef G_ENABLE_DEBUG
2926
2927 gchar *
2928 gdk_win32_message_name (UINT msg)
2929 {
2930   static gchar bfr[100];
2931
2932   switch (msg)
2933     {
2934 #define CASE(x) case x: return #x
2935       CASE (WM_NULL);
2936       CASE (WM_CREATE);
2937       CASE (WM_DESTROY);
2938       CASE (WM_MOVE);
2939       CASE (WM_SIZE);
2940       CASE (WM_ACTIVATE);
2941       CASE (WM_SETFOCUS);
2942       CASE (WM_KILLFOCUS);
2943       CASE (WM_ENABLE);
2944       CASE (WM_SETREDRAW);
2945       CASE (WM_SETTEXT);
2946       CASE (WM_GETTEXT);
2947       CASE (WM_GETTEXTLENGTH);
2948       CASE (WM_PAINT);
2949       CASE (WM_CLOSE);
2950       CASE (WM_QUERYENDSESSION);
2951       CASE (WM_QUERYOPEN);
2952       CASE (WM_ENDSESSION);
2953       CASE (WM_QUIT);
2954       CASE (WM_ERASEBKGND);
2955       CASE (WM_SYSCOLORCHANGE);
2956       CASE (WM_SHOWWINDOW);
2957       CASE (WM_WININICHANGE);
2958       CASE (WM_DEVMODECHANGE);
2959       CASE (WM_ACTIVATEAPP);
2960       CASE (WM_FONTCHANGE);
2961       CASE (WM_TIMECHANGE);
2962       CASE (WM_CANCELMODE);
2963       CASE (WM_SETCURSOR);
2964       CASE (WM_MOUSEACTIVATE);
2965       CASE (WM_CHILDACTIVATE);
2966       CASE (WM_QUEUESYNC);
2967       CASE (WM_GETMINMAXINFO);
2968       CASE (WM_PAINTICON);
2969       CASE (WM_ICONERASEBKGND);
2970       CASE (WM_NEXTDLGCTL);
2971       CASE (WM_SPOOLERSTATUS);
2972       CASE (WM_DRAWITEM);
2973       CASE (WM_MEASUREITEM);
2974       CASE (WM_DELETEITEM);
2975       CASE (WM_VKEYTOITEM);
2976       CASE (WM_CHARTOITEM);
2977       CASE (WM_SETFONT);
2978       CASE (WM_GETFONT);
2979       CASE (WM_SETHOTKEY);
2980       CASE (WM_GETHOTKEY);
2981       CASE (WM_QUERYDRAGICON);
2982       CASE (WM_COMPAREITEM);
2983       CASE (WM_GETOBJECT);
2984       CASE (WM_COMPACTING);
2985       CASE (WM_WINDOWPOSCHANGING);
2986       CASE (WM_WINDOWPOSCHANGED);
2987       CASE (WM_POWER);
2988       CASE (WM_COPYDATA);
2989       CASE (WM_CANCELJOURNAL);
2990       CASE (WM_NOTIFY);
2991       CASE (WM_INPUTLANGCHANGEREQUEST);
2992       CASE (WM_INPUTLANGCHANGE);
2993       CASE (WM_TCARD);
2994       CASE (WM_HELP);
2995       CASE (WM_USERCHANGED);
2996       CASE (WM_NOTIFYFORMAT);
2997       CASE (WM_CONTEXTMENU);
2998       CASE (WM_STYLECHANGING);
2999       CASE (WM_STYLECHANGED);
3000       CASE (WM_DISPLAYCHANGE);
3001       CASE (WM_GETICON);
3002       CASE (WM_SETICON);
3003       CASE (WM_NCCREATE);
3004       CASE (WM_NCDESTROY);
3005       CASE (WM_NCCALCSIZE);
3006       CASE (WM_NCHITTEST);
3007       CASE (WM_NCPAINT);
3008       CASE (WM_NCACTIVATE);
3009       CASE (WM_GETDLGCODE);
3010       CASE (WM_SYNCPAINT);
3011       CASE (WM_NCMOUSEMOVE);
3012       CASE (WM_NCLBUTTONDOWN);
3013       CASE (WM_NCLBUTTONUP);
3014       CASE (WM_NCLBUTTONDBLCLK);
3015       CASE (WM_NCRBUTTONDOWN);
3016       CASE (WM_NCRBUTTONUP);
3017       CASE (WM_NCRBUTTONDBLCLK);
3018       CASE (WM_NCMBUTTONDOWN);
3019       CASE (WM_NCMBUTTONUP);
3020       CASE (WM_NCMBUTTONDBLCLK);
3021       CASE (WM_NCXBUTTONDOWN);
3022       CASE (WM_NCXBUTTONUP);
3023       CASE (WM_NCXBUTTONDBLCLK);
3024       CASE (WM_KEYDOWN);
3025       CASE (WM_KEYUP);
3026       CASE (WM_CHAR);
3027       CASE (WM_DEADCHAR);
3028       CASE (WM_SYSKEYDOWN);
3029       CASE (WM_SYSKEYUP);
3030       CASE (WM_SYSCHAR);
3031       CASE (WM_SYSDEADCHAR);
3032       CASE (WM_KEYLAST);
3033       CASE (WM_IME_STARTCOMPOSITION);
3034       CASE (WM_IME_ENDCOMPOSITION);
3035       CASE (WM_IME_COMPOSITION);
3036       CASE (WM_INITDIALOG);
3037       CASE (WM_COMMAND);
3038       CASE (WM_SYSCOMMAND);
3039       CASE (WM_TIMER);
3040       CASE (WM_HSCROLL);
3041       CASE (WM_VSCROLL);
3042       CASE (WM_INITMENU);
3043       CASE (WM_INITMENUPOPUP);
3044       CASE (WM_MENUSELECT);
3045       CASE (WM_MENUCHAR);
3046       CASE (WM_ENTERIDLE);
3047       CASE (WM_MENURBUTTONUP);
3048       CASE (WM_MENUDRAG);
3049       CASE (WM_MENUGETOBJECT);
3050       CASE (WM_UNINITMENUPOPUP);
3051       CASE (WM_MENUCOMMAND);
3052       CASE (WM_CHANGEUISTATE);
3053       CASE (WM_UPDATEUISTATE);
3054       CASE (WM_QUERYUISTATE);
3055       CASE (WM_CTLCOLORMSGBOX);
3056       CASE (WM_CTLCOLOREDIT);
3057       CASE (WM_CTLCOLORLISTBOX);
3058       CASE (WM_CTLCOLORBTN);
3059       CASE (WM_CTLCOLORDLG);
3060       CASE (WM_CTLCOLORSCROLLBAR);
3061       CASE (WM_CTLCOLORSTATIC);
3062       CASE (WM_MOUSEMOVE);
3063       CASE (WM_LBUTTONDOWN);
3064       CASE (WM_LBUTTONUP);
3065       CASE (WM_LBUTTONDBLCLK);
3066       CASE (WM_RBUTTONDOWN);
3067       CASE (WM_RBUTTONUP);
3068       CASE (WM_RBUTTONDBLCLK);
3069       CASE (WM_MBUTTONDOWN);
3070       CASE (WM_MBUTTONUP);
3071       CASE (WM_MBUTTONDBLCLK);
3072       CASE (WM_MOUSEWHEEL);
3073       CASE (WM_XBUTTONDOWN);
3074       CASE (WM_XBUTTONUP);
3075       CASE (WM_XBUTTONDBLCLK);
3076       CASE (WM_PARENTNOTIFY);
3077       CASE (WM_ENTERMENULOOP);
3078       CASE (WM_EXITMENULOOP);
3079       CASE (WM_NEXTMENU);
3080       CASE (WM_SIZING);
3081       CASE (WM_CAPTURECHANGED);
3082       CASE (WM_MOVING);
3083       CASE (WM_POWERBROADCAST);
3084       CASE (WM_DEVICECHANGE);
3085       CASE (WM_MDICREATE);
3086       CASE (WM_MDIDESTROY);
3087       CASE (WM_MDIACTIVATE);
3088       CASE (WM_MDIRESTORE);
3089       CASE (WM_MDINEXT);
3090       CASE (WM_MDIMAXIMIZE);
3091       CASE (WM_MDITILE);
3092       CASE (WM_MDICASCADE);
3093       CASE (WM_MDIICONARRANGE);
3094       CASE (WM_MDIGETACTIVE);
3095       CASE (WM_MDISETMENU);
3096       CASE (WM_ENTERSIZEMOVE);
3097       CASE (WM_EXITSIZEMOVE);
3098       CASE (WM_DROPFILES);
3099       CASE (WM_MDIREFRESHMENU);
3100       CASE (WM_IME_SETCONTEXT);
3101       CASE (WM_IME_NOTIFY);
3102       CASE (WM_IME_CONTROL);
3103       CASE (WM_IME_COMPOSITIONFULL);
3104       CASE (WM_IME_SELECT);
3105       CASE (WM_IME_CHAR);
3106       CASE (WM_IME_REQUEST);
3107       CASE (WM_IME_KEYDOWN);
3108       CASE (WM_IME_KEYUP);
3109       CASE (WM_MOUSEHOVER);
3110       CASE (WM_MOUSELEAVE);
3111       CASE (WM_NCMOUSEHOVER);
3112       CASE (WM_NCMOUSELEAVE);
3113       CASE (WM_CUT);
3114       CASE (WM_COPY);
3115       CASE (WM_PASTE);
3116       CASE (WM_CLEAR);
3117       CASE (WM_UNDO);
3118       CASE (WM_RENDERFORMAT);
3119       CASE (WM_RENDERALLFORMATS);
3120       CASE (WM_DESTROYCLIPBOARD);
3121       CASE (WM_DRAWCLIPBOARD);
3122       CASE (WM_PAINTCLIPBOARD);
3123       CASE (WM_VSCROLLCLIPBOARD);
3124       CASE (WM_SIZECLIPBOARD);
3125       CASE (WM_ASKCBFORMATNAME);
3126       CASE (WM_CHANGECBCHAIN);
3127       CASE (WM_HSCROLLCLIPBOARD);
3128       CASE (WM_QUERYNEWPALETTE);
3129       CASE (WM_PALETTEISCHANGING);
3130       CASE (WM_PALETTECHANGED);
3131       CASE (WM_HOTKEY);
3132       CASE (WM_PRINT);
3133       CASE (WM_PRINTCLIENT);
3134       CASE (WM_APPCOMMAND);
3135       CASE (WM_HANDHELDFIRST);
3136       CASE (WM_HANDHELDLAST);
3137       CASE (WM_AFXFIRST);
3138       CASE (WM_AFXLAST);
3139       CASE (WM_PENWINFIRST);
3140       CASE (WM_PENWINLAST);
3141       CASE (WM_APP);
3142 #undef CASE
3143     default:
3144       if (msg >= WM_HANDHELDFIRST && msg <= WM_HANDHELDLAST)
3145         sprintf (bfr, "WM_HANDHELDFIRST+%d", msg - WM_HANDHELDFIRST);
3146       else if (msg >= WM_AFXFIRST && msg <= WM_AFXLAST)
3147         sprintf (bfr, "WM_AFXFIRST+%d", msg - WM_AFXFIRST);
3148       else if (msg >= WM_PENWINFIRST && msg <= WM_PENWINLAST)
3149         sprintf (bfr, "WM_PENWINFIRST+%d", msg - WM_PENWINFIRST);
3150       else if (msg >= WM_USER && msg <= 0x7FFF)
3151         sprintf (bfr, "WM_USER+%d", msg - WM_USER);
3152       else if (msg >= 0xC000 && msg <= 0xFFFF)
3153         sprintf (bfr, "reg-%#x", msg);
3154       else
3155         sprintf (bfr, "unk-%#x", msg);
3156       return bfr;
3157     }
3158   g_assert_not_reached ();
3159 }
3160
3161 #endif /* G_ENABLE_DEBUG */