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