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-2002 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 /* Cannot use TrackMouseEvent, as the stupid WM_MOUSELEAVE message
  29  * doesn't tell us where the mouse has gone. Thus we cannot use it to
  30  * generate a correct GdkNotifyType. Pity, as using TrackMouseEvent
  31  * otherwise would make it possible to reliably generate
  32  * GDK_LEAVE_NOTIFY events, which would help get rid of those pesky
  33  * tooltips sometimes popping up in the wrong place.
  34  *
  35  * Update: a combination of TrackMouseEvent, GetCursorPos and
  36  * GetWindowPos can and is actually used to get rid of those
  37  * pesky tooltips. It should be possible to use this for the
  38  * whole ENTER/LEAVE NOTIFY handling but some platforms may
  39  * not have TrackMouseEvent at all (?) --hb
  40  */
  41
  42 #include <config.h>
  43
  44 #include <glib/gprintf.h>
  45
  46 #if defined (__GNUC__) && defined (HAVE_DIMM_H)
  47 /* The w32api imm.h clashes a bit with the IE5.5 dimm.h */
  48 # define IMEMENUITEMINFOA hidden_IMEMENUITEMINFOA
  49 # define IMEMENUITEMINFOW hidden_IMEMENUITEMINFOW
  50 #endif
  51
  52 #include "gdk.h"
  53 #include "gdkprivate-win32.h"
  54 #include "gdkinput-win32.h"
  55 #include "gdkkeysyms.h"
  56
  57 #include <windowsx.h>
  58
  59 #ifdef G_WITH_CYGWIN
  60 #include <fcntl.h>
  61 #include <errno.h>
  62 #endif
  63
  64 #include <objbase.h>
  65
  66 #include <imm.h>
  67
  68 #if defined (__GNUC__) && defined (HAVE_DIMM_H)
  69 # undef IMEMENUITEMINFOA
  70 # undef IMEMENUITEMINFOW
  71 #endif
  72
  73 #ifdef HAVE_DIMM_H
  74 #include <dimm.h>
  75 #endif
  76
  77 #ifndef XBUTTON1
  78 #define XBUTTON1 1
  79 #define XBUTTON2 2
  80 #endif
  81
  82 #ifndef VK_XBUTTON1
  83 #define VK_XBUTTON1 5
  84 #define VK_XBUTTON2 6
  85 #endif
  86
  87 #ifndef MK_XBUTTON1
  88 #define MK_XBUTTON1 32
  89 #define MK_XBUTTON2 64
  90 #endif
  91
  92 /*
  93  * Private function declarations
  94  */
  95
  96 static GdkFilterReturn
  97                  gdk_event_apply_filters(MSG      *msg,
  98                                          GdkEvent *event,
  99                                          GList    *filters);
 100 static gboolean  gdk_event_translate    (GdkDisplay *display,
 101                                          MSG        *msg,
 102                                          gint       *ret_valp);
 103 static void      handle_wm_paint        (MSG        *msg,
 104                                          GdkWindow  *window,
 105                                          gboolean    return_exposes,
 106                                          GdkEvent  **event);
 107
 108 static gboolean gdk_event_prepare  (GSource     *source,
 109                                     gint        *timeout);
 110 static gboolean gdk_event_check    (GSource     *source);
 111 static gboolean gdk_event_dispatch (GSource     *source,
 112                                     GSourceFunc  callback,
 113                                     gpointer     user_data);
 114
 115 static void append_event (GdkDisplay *display,
 116                           GdkEvent   *event);
 117
 118 /* Private variable declarations
 119  */
 120
 121 static GdkWindow *p_grab_window = NULL; /* Window that currently holds
 122                                          * the pointer grab
 123                                          */
 124
 125 static GdkWindow *p_grab_confine_to = NULL;
 126
 127 static GdkWindow *k_grab_window = NULL; /* Window the holds the
 128                                          * keyboard grab
 129                                          */
 130
 131 static GList *client_filters;   /* Filters for client messages */
 132
 133 static gboolean p_grab_automatic;
 134 static GdkEventMask p_grab_mask;
 135 static gboolean p_grab_owner_events, k_grab_owner_events;
 136 static HCURSOR p_grab_cursor;
 137
 138 static GSourceFuncs event_funcs = {
 139   gdk_event_prepare,
 140   gdk_event_check,
 141   gdk_event_dispatch,
 142   NULL
 143 };
 144
 145 GPollFD event_poll_fd;
 146
 147 static GdkWindow *current_window = NULL;
 148 static gint current_x, current_y;
 149 #if 0
 150 static UINT gdk_ping_msg;
 151 #endif
 152 static UINT msh_mousewheel;
 153 static UINT client_message;
 154
 155 #ifdef HAVE_DIMM_H
 156 static IActiveIMMApp *active_imm_app = NULL;
 157 static IActiveIMMMessagePumpOwner *active_imm_msgpump_owner = NULL;
 158 #endif
 159
 160 #if 0
 161 static HKL latin_locale = NULL;
 162 #endif
 163
 164 static gboolean in_ime_composition = FALSE;
 165 static UINT     resize_timer;
 166
 167 static int debug_indent = 0;
 168
 169 static void
 170 assign_object (gpointer lhsp,
 171                gpointer rhs)
 172 {
 173   if (*(gpointer *)lhsp != rhs)
 174     {
 175       if (*(gpointer *)lhsp != NULL)
 176         g_object_unref (*(gpointer *)lhsp);
 177       *(gpointer *)lhsp = rhs;
 178       if (rhs != NULL)
 179         g_object_ref (rhs);
 180     }
 181 }
 182
 183 static void
 184 track_mouse_event (DWORD dwFlags,
 185                    HWND  hwnd)
 186 {
 187   typedef BOOL (WINAPI *PFN_TrackMouseEvent) (LPTRACKMOUSEEVENT);
 188   static PFN_TrackMouseEvent p_TrackMouseEvent = NULL;
 189   static gboolean once = FALSE;
 190
 191   if (!once)
 192     {
 193       HMODULE user32;
 194       HINSTANCE commctrl32;
 195
 196       user32 = GetModuleHandle ("user32.dll");
 197       if ((p_TrackMouseEvent = (PFN_TrackMouseEvent)GetProcAddress (user32, "TrackMouseEvent")) == NULL)
 198         {
 199           if ((commctrl32 = LoadLibrary ("commctrl32.dll")) != NULL)
 200             p_TrackMouseEvent = (PFN_TrackMouseEvent)
 201               GetProcAddress (commctrl32, "_TrackMouseEvent");
 202         }
 203       once = TRUE;
 204     }
 205
 206   if (p_TrackMouseEvent)
 207     {
 208       TRACKMOUSEEVENT tme;
 209       tme.cbSize = sizeof(TRACKMOUSEEVENT);
 210       tme.dwFlags = dwFlags;
 211       tme.hwndTrack = hwnd;
 212       tme.dwHoverTime = HOVER_DEFAULT; /* not used */
 213
 214       if (!p_TrackMouseEvent (&tme))
 215         WIN32_API_FAILED ("TrackMouseEvent");
 216       else if (dwFlags == TME_LEAVE)
 217         GDK_NOTE (EVENTS, g_print(" (TrackMouseEvent %p)", hwnd));
 218       else if (dwFlags == TME_CANCEL)
 219         GDK_NOTE (EVENTS, g_print(" (cancel TrackMouseEvent %p)", hwnd));
 220     }
 221 }
 222
 223 gulong
 224 _gdk_win32_get_next_tick (gulong suggested_tick)
 225 {
 226   static gulong cur_tick = 0;
 227
 228   if (suggested_tick == 0)
 229     suggested_tick = GetTickCount ();
 230   if (suggested_tick <= cur_tick)
 231     return cur_tick;
 232   else
 233     return cur_tick = suggested_tick;
 234 }
 235
 236 static void
 237 generate_focus_event (GdkWindow *window,
 238                       gboolean   in)
 239 {
 240   GdkEvent *event;
 241
 242   event = gdk_event_new (GDK_FOCUS_CHANGE);
 243   event->focus_change.window = window;
 244   event->focus_change.in = in;
 245
 246   append_event (gdk_drawable_get_display (window), event);
 247 }
 248
 249 static LRESULT
 250 inner_window_procedure (HWND   hwnd,
 251                         UINT   message,
 252                         WPARAM wparam,
 253                         LPARAM lparam)
 254 {
 255   GdkDisplay *display = gdk_display_get_default ();
 256   MSG msg;
 257   DWORD pos;
 258 #ifdef HAVE_DIMM_H
 259   LRESULT lres;
 260 #endif
 261   gint ret_val = 0;
 262
 263   msg.hwnd = hwnd;
 264   msg.message = message;
 265   msg.wParam = wparam;
 266   msg.lParam = lparam;
 267   msg.time = _gdk_win32_get_next_tick (0);
 268   pos = GetMessagePos ();
 269   msg.pt.x = GET_X_LPARAM (pos);
 270   msg.pt.y = GET_Y_LPARAM (pos);
 271
 272   if (gdk_event_translate (display, &msg, &ret_val))
 273     {
 274       /* If gdk_event_translate() returns TRUE, we return ret_val from
 275        * the window procedure.
 276        */
 277       return ret_val;
 278     }
 279   else
 280     {
 281       /* Otherwise call DefWindowProc(). */
 282       GDK_NOTE (EVENTS, g_print (" DefWindowProc"));
 283 #ifndef HAVE_DIMM_H
 284       return DefWindowProc (hwnd, message, wparam, lparam);
 285 #else
 286       if (active_imm_app == NULL ||
 287           (*active_imm_app->lpVtbl->OnDefWindowProc) (active_imm_app, hwnd, message, wparam, lparam, &lres) == S_FALSE)
 288         return DefWindowProc (hwnd, message, wparam, lparam);
 289       else
 290         return lres;
 291 #endif
 292     }
 293 }
 294
 295 LRESULT CALLBACK
 296 _gdk_win32_window_procedure (HWND   hwnd,
 297                              UINT   message,
 298                              WPARAM wparam,
 299                              LPARAM lparam)
 300 {
 301   LRESULT retval;
 302
 303   GDK_NOTE (EVENTS, g_print ("%s%*s%s %p",
 304                              (debug_indent > 0 ? "\n" : ""),
 305                              debug_indent, "",
 306                              _gdk_win32_message_to_string (message), hwnd));
 307   debug_indent += 2;
 308   retval = inner_window_procedure (hwnd, message, wparam, lparam);
 309   debug_indent -= 2;
 310
 311   GDK_NOTE (EVENTS, g_print (" => %ld%s",
 312                              retval, (debug_indent == 0 ? "\n" : "")));
 313
 314   return retval;
 315 }
 316
 317 void
 318 _gdk_events_init (void)
 319 {
 320   GSource *source;
 321 #ifdef HAVE_DIMM_H
 322   HRESULT hres;
 323 #endif
 324
 325 #if 0
 326   int i, j, n;
 327
 328   /* List of languages that use a latin keyboard. Somewhat sorted in
 329    * "order of least surprise", in case we have to load one of them if
 330    * the user only has arabic loaded, for instance.
 331    */
 332   static int latin_languages[] = {
 333     LANG_ENGLISH,
 334     LANG_SPANISH,
 335     LANG_PORTUGUESE,
 336     LANG_FRENCH,
 337     LANG_GERMAN,
 338     /* Rest in numeric order */
 339     LANG_CZECH,
 340     LANG_DANISH,
 341     LANG_FINNISH,
 342     LANG_HUNGARIAN,
 343     LANG_ICELANDIC,
 344     LANG_ITALIAN,
 345     LANG_DUTCH,
 346     LANG_NORWEGIAN,
 347     LANG_POLISH,
 348     LANG_ROMANIAN,
 349     LANG_SLOVAK,
 350     LANG_ALBANIAN,
 351     LANG_SWEDISH,
 352     LANG_TURKISH,
 353     LANG_INDONESIAN,
 354     LANG_SLOVENIAN,
 355     LANG_ESTONIAN,
 356     LANG_LATVIAN,
 357     LANG_LITHUANIAN,
 358     LANG_VIETNAMESE,
 359     LANG_AFRIKAANS,
 360     LANG_FAEROESE
 361 #ifdef LANG_SWAHILI
 362    ,LANG_SWAHILI
 363 #endif
 364   };
 365 #endif
 366
 367 #if 0
 368   gdk_ping_msg = RegisterWindowMessage ("gdk-ping");
 369   GDK_NOTE (EVENTS, g_print ("gdk-ping = %#x\n", gdk_ping_msg));
 370 #endif
 371
 372   /* This is the string MSH_MOUSEWHEEL from zmouse.h,
 373    * http://www.microsoft.com/mouse/intellimouse/sdk/zmouse.h
 374    * This message is used by mouse drivers than cannot generate WM_MOUSEWHEEL
 375    * or on Win95.
 376    */
 377   msh_mousewheel = RegisterWindowMessage ("MSWHEEL_ROLLMSG");
 378
 379   client_message = RegisterWindowMessage ("GDK_WIN32_CLIENT_MESSAGE");
 380
 381 #if 0
 382   /* Check if we have some input locale identifier loaded that uses a
 383    * latin keyboard, to be able to get the virtual-key code for the
 384    * latin characters corresponding to ASCII control characters.
 385    */
 386   if ((n = GetKeyboardLayoutList (0, NULL)) == 0)
 387     WIN32_API_FAILED ("GetKeyboardLayoutList");
 388   else
 389     {
 390       HKL *hkl_list = g_new (HKL, n);
 391       if (GetKeyboardLayoutList (n, hkl_list) == 0)
 392         WIN32_API_FAILED ("GetKeyboardLayoutList");
 393       else
 394         {
 395           for (i = 0; latin_locale == NULL && i < n; i++)
 396             for (j = 0; j < G_N_ELEMENTS (latin_languages); j++)
 397               if (PRIMARYLANGID (LOWORD (hkl_list[i])) == latin_languages[j])
 398                 {
 399                   latin_locale = hkl_list [i];
 400                   break;
 401                 }
 402         }
 403       g_free (hkl_list);
 404     }
 405
 406   if (latin_locale == NULL)
 407     {
 408       /* Try to load a keyboard layout with latin characters then.
 409        */
 410       i = 0;
 411       while (latin_locale == NULL && i < G_N_ELEMENTS (latin_languages))
 412         {
 413           char id[9];
 414           g_sprintf (id, "%08x", MAKELANGID (latin_languages[i++], SUBLANG_DEFAULT));
 415           latin_locale = LoadKeyboardLayout (id, KLF_NOTELLSHELL|KLF_SUBSTITUTE_OK);
 416         }
 417     }
 418
 419   GDK_NOTE (EVENTS, g_print ("latin_locale = %08x\n", (guint) latin_locale));
 420 #endif
 421
 422   source = g_source_new (&event_funcs, sizeof (GSource));
 423   g_source_set_priority (source, GDK_PRIORITY_EVENTS);
 424
 425 #ifdef G_WITH_CYGWIN
 426   event_poll_fd.fd = open ("/dev/windows", O_RDONLY);
 427   if (event_poll_fd.fd == -1)
 428     g_error ("can't open \"/dev/windows\": %s", g_strerror (errno));
 429 #else
 430   event_poll_fd.fd = G_WIN32_MSG_HANDLE;
 431 #endif
 432   event_poll_fd.events = G_IO_IN;
 433
 434   g_source_add_poll (source, &event_poll_fd);
 435   g_source_set_can_recurse (source, TRUE);
 436   g_source_attach (source, NULL);
 437
 438 #ifdef HAVE_DIMM_H
 439   hres = CoCreateInstance (&CLSID_CActiveIMM,
 440                            NULL,
 441                            CLSCTX_ALL,
 442                            &IID_IActiveIMMApp,
 443                            (LPVOID *) &active_imm_app);
 444
 445   if (hres == S_OK)
 446     {
 447       GDK_NOTE (EVENTS, g_print ("IActiveIMMApp created %p\n",
 448                                  active_imm_app));
 449       (*active_imm_app->lpVtbl->Activate) (active_imm_app, TRUE);
 450
 451       hres = (*active_imm_app->lpVtbl->QueryInterface) (active_imm_app, &IID_IActiveIMMMessagePumpOwner, (void **) &active_imm_msgpump_owner);
 452       GDK_NOTE (EVENTS, g_print ("IActiveIMMMessagePumpOwner created %p\n",
 453                                  active_imm_msgpump_owner));
 454       (active_imm_msgpump_owner->lpVtbl->Start) (active_imm_msgpump_owner);
 455     }
 456 #endif
 457 }
 458
 459 gboolean
 460 gdk_events_pending (void)
 461 {
 462   MSG msg;
 463   GdkDisplay *display = gdk_display_get_default ();
 464
 465   return (_gdk_event_queue_find_first (display) ||
 466           PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
 467 }
 468
 469 GdkEvent*
 470 gdk_event_get_graphics_expose (GdkWindow *window)
 471 {
 472   MSG msg;
 473   GdkEvent *event = NULL;
 474
 475   g_return_val_if_fail (window != NULL, NULL);
 476
 477   GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose\n"));
 478
 479   if (PeekMessage (&msg, GDK_WINDOW_HWND (window), WM_PAINT, WM_PAINT, PM_REMOVE))
 480     {
 481       handle_wm_paint (&msg, window, TRUE, &event);
 482       if (event != NULL)
 483         {
 484           GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: got it!\n"));
 485           return event;
 486         }
 487     }
 488
 489   GDK_NOTE (EVENTS, g_print ("gdk_event_get_graphics_expose: nope\n"));
 490   return NULL;
 491 }
 492
 493 static char *
 494 event_mask_string (GdkEventMask mask)
 495 {
 496   static char bfr[500];
 497   char *p = bfr;
 498
 499   *p = '\0';
 500 #define BIT(x) \
 501   if (mask & GDK_##x##_MASK) \
 502     p += g_sprintf (p, "%s" #x, (p > bfr ? " " : ""))
 503   BIT (EXPOSURE);
 504   BIT (POINTER_MOTION);
 505   BIT (POINTER_MOTION_HINT);
 506   BIT (BUTTON_MOTION);
 507   BIT (BUTTON1_MOTION);
 508   BIT (BUTTON2_MOTION);
 509   BIT (BUTTON3_MOTION);
 510   BIT (BUTTON_PRESS);
 511   BIT (BUTTON_RELEASE);
 512   BIT (KEY_PRESS);
 513   BIT (KEY_RELEASE);
 514   BIT (ENTER_NOTIFY);
 515   BIT (LEAVE_NOTIFY);
 516   BIT (FOCUS_CHANGE);
 517   BIT (STRUCTURE);
 518   BIT (PROPERTY_CHANGE);
 519   BIT (VISIBILITY_NOTIFY);
 520   BIT (PROXIMITY_IN);
 521   BIT (PROXIMITY_OUT);
 522   BIT (SUBSTRUCTURE);
 523   BIT (SCROLL);
 524 #undef BIT
 525
 526   return bfr;
 527 }
 528
 529 GdkGrabStatus
 530 gdk_pointer_grab (GdkWindow    *window,
 531                   gboolean      owner_events,
 532                   GdkEventMask  event_mask,
 533                   GdkWindow    *confine_to,
 534                   GdkCursor    *cursor,
 535                   guint32       time)
 536 {
 537   HCURSOR hcursor;
 538   GdkCursorPrivate *cursor_private;
 539   gint return_val = GDK_GRAB_SUCCESS;
 540
 541   g_return_val_if_fail (window != NULL, 0);
 542   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 543   g_return_val_if_fail (confine_to == NULL || GDK_IS_WINDOW (confine_to), 0);
 544
 545   cursor_private = (GdkCursorPrivate*) cursor;
 546
 547   if (!cursor)
 548     hcursor = NULL;
 549   else if ((hcursor = CopyCursor (cursor_private->hcursor)) == NULL)
 550     WIN32_API_FAILED ("CopyCursor");
 551
 552   return_val = _gdk_input_grab_pointer (window,
 553                                         owner_events,
 554                                         event_mask,
 555                                         confine_to,
 556                                         time);
 557
 558   if (return_val == GDK_GRAB_SUCCESS)
 559     {
 560       if (!GDK_WINDOW_DESTROYED (window))
 561         {
 562           GDK_NOTE (EVENTS, g_print ("%sgdk_pointer_grab: %p %s %p %s%s",
 563                                      (debug_indent > 0 ? "\n" : ""),
 564                                      GDK_WINDOW_HWND (window),
 565                                      (owner_events ? "TRUE" : "FALSE"),
 566                                      hcursor,
 567                                      event_mask_string (event_mask),
 568                                      (debug_indent == 0 ? "\n" : "")));
 569
 570           p_grab_mask = event_mask;
 571           p_grab_owner_events = owner_events;
 572           p_grab_automatic = FALSE;
 573
 574           SetCapture (GDK_WINDOW_HWND (window));
 575           return_val = GDK_GRAB_SUCCESS;
 576         }
 577       else
 578         return_val = GDK_GRAB_ALREADY_GRABBED;
 579     }
 580
 581   if (return_val == GDK_GRAB_SUCCESS)
 582     {
 583       GdkWindowImplWin32 *impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
 584       p_grab_window = window;
 585
 586       if (p_grab_cursor != NULL)
 587         {
 588           if (GetCursor () == p_grab_cursor)
 589             SetCursor (NULL);
 590           DestroyCursor (p_grab_cursor);
 591         }
 592
 593       p_grab_cursor = hcursor;
 594
 595       if (p_grab_cursor != NULL)
 596         SetCursor (p_grab_cursor);
 597       else if (impl->hcursor != NULL)
 598         SetCursor (impl->hcursor);
 599       else
 600         SetCursor (LoadCursor (NULL, IDC_ARROW));
 601
 602       if (confine_to != NULL)
 603         {
 604           gint x, y, width, height;
 605           RECT rect;
 606
 607           gdk_window_get_origin (confine_to, &x, &y);
 608           gdk_drawable_get_size (confine_to, &width, &height);
 609
 610           rect.left = x;
 611           rect.top = y;
 612           rect.right = x + width;
 613           rect.bottom = y + height;
 614           API_CALL (ClipCursor, (&rect));
 615           p_grab_confine_to = confine_to;
 616         }
 617
 618       /* FIXME: Generate GDK_CROSSING_GRAB events */
 619     }
 620
 621   return return_val;
 622 }
 623
 624 void
 625 gdk_display_pointer_ungrab (GdkDisplay *display,
 626                             guint32     time)
 627 {
 628   g_return_if_fail (display == gdk_display_get_default ());
 629
 630   GDK_NOTE (EVENTS, g_print ("%sgdk_display_pointer_ungrab%s",
 631                              (debug_indent > 0 ? "\n" : ""),
 632                              (debug_indent == 0 ? "\n" : "")));
 633
 634   _gdk_input_ungrab_pointer (time);
 635
 636   if (GetCapture () != NULL)
 637     ReleaseCapture ();
 638
 639   /* FIXME: Generate GDK_CROSSING_UNGRAB events */
 640
 641   p_grab_window = NULL;
 642   if (p_grab_cursor != NULL)
 643     {
 644       if (GetCursor () == p_grab_cursor)
 645         SetCursor (NULL);
 646       DestroyCursor (p_grab_cursor);
 647       p_grab_cursor = NULL;
 648     }
 649
 650   if (p_grab_confine_to != NULL)
 651     {
 652       API_CALL (ClipCursor, (NULL));
 653       p_grab_confine_to = NULL;
 654     }
 655 }
 656
 657 static GdkWindow *
 658 find_real_window_for_grabbed_mouse_event (GdkWindow* reported_window,
 659                                           MSG*       msg)
 660 {
 661   HWND hwnd;
 662   POINTS points;
 663   POINT pt;
 664   GdkWindow* other_window = NULL;
 665
 666   points = MAKEPOINTS (msg->lParam);
 667   pt.x = points.x;
 668   pt.y = points.y;
 669   ClientToScreen (msg->hwnd, &pt);
 670
 671   hwnd = WindowFromPoint (pt);
 672
 673   if (hwnd != NULL)
 674     {
 675       RECT rect;
 676
 677       GetClientRect (hwnd, &rect);
 678       ScreenToClient (hwnd, &pt);
 679       if (!PtInRect (&rect, pt))
 680         return _gdk_root;
 681
 682       other_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) hwnd);
 683     }
 684
 685   if (other_window == NULL)
 686     return _gdk_root;
 687
 688   return other_window;
 689 }
 690
 691 static GdkWindow*
 692 find_window_for_mouse_event (GdkWindow* reported_window,
 693                              MSG*       msg)
 694 {
 695   if (p_grab_window == NULL || !p_grab_owner_events)
 696     return reported_window;
 697   else
 698     return find_real_window_for_grabbed_mouse_event (reported_window, msg);
 699 }
 700
 701 gboolean
 702 gdk_display_pointer_is_grabbed (GdkDisplay *display)
 703 {
 704   g_return_val_if_fail (display == gdk_display_get_default (), FALSE);
 705   GDK_NOTE (EVENTS, g_print ("gdk_pointer_is_grabbed: %s\n",
 706                              p_grab_window != NULL ? "TRUE" : "FALSE"));
 707   return p_grab_window != NULL;
 708 }
 709
 710 gboolean
 711 gdk_pointer_grab_info_libgtk_only (GdkDisplay *display,
 712                                    GdkWindow **grab_window,
 713                                    gboolean   *owner_events)
 714 {
 715   g_return_val_if_fail (display == gdk_display_get_default (), FALSE);
 716
 717   if (p_grab_window != NULL)
 718     {
 719       if (grab_window)
 720         *grab_window = p_grab_window;
 721       if (owner_events)
 722         *owner_events = p_grab_owner_events;
 723
 724       return TRUE;
 725     }
 726   else
 727     return FALSE;
 728 }
 729
 730 GdkGrabStatus
 731 gdk_keyboard_grab (GdkWindow *window,
 732                    gboolean   owner_events,
 733                    guint32    time)
 734 {
 735   GdkWindow *real_focus_window, *grab_focus_window;
 736
 737   gint return_val;
 738
 739   g_return_val_if_fail (window != NULL, 0);
 740   g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
 741
 742   GDK_NOTE (EVENTS, g_print ("gdk_keyboard_grab %p\n",
 743                              GDK_WINDOW_HWND (window)));
 744
 745   if (!GDK_WINDOW_DESTROYED (window))
 746     {
 747       k_grab_owner_events = owner_events != 0;
 748       return_val = GDK_GRAB_SUCCESS;
 749     }
 750   else
 751     return_val = GDK_GRAB_ALREADY_GRABBED;
 752
 753   if (return_val == GDK_GRAB_SUCCESS)
 754     {
 755       k_grab_window = window;
 756
 757       if (!k_grab_owner_events)
 758         {
 759           real_focus_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) GetFocus ());
 760           if (real_focus_window)
 761             real_focus_window = gdk_window_get_toplevel (real_focus_window);
 762           grab_focus_window = gdk_window_get_toplevel (k_grab_window);
 763           if (real_focus_window != grab_focus_window)
 764             {
 765               /* Generate events for focus change from the window that really
 766                * has focus to the grabber.
 767                */
 768               if (real_focus_window && !GDK_WINDOW_DESTROYED (real_focus_window)
 769                   && (((GdkWindowObject *) real_focus_window)->event_mask
 770                       & GDK_FOCUS_CHANGE_MASK))
 771                 generate_focus_event (real_focus_window, FALSE);
 772
 773               if (((GdkWindowObject *) grab_focus_window)->event_mask
 774                   & GDK_FOCUS_CHANGE_MASK)
 775                 generate_focus_event (grab_focus_window, TRUE);
 776             }
 777         }
 778     }
 779
 780   return return_val;
 781 }
 782
 783 void
 784 gdk_display_keyboard_ungrab (GdkDisplay *display,
 785                              guint32 time)
 786 {
 787   GdkWindow *real_focus_window, *grab_focus_window;
 788
 789   g_return_if_fail (display == gdk_display_get_default ());
 790
 791   GDK_NOTE (EVENTS, g_print ("gdk_keyboard_ungrab\n"));
 792
 793   if (k_grab_window && !k_grab_owner_events)
 794     {
 795       real_focus_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) GetFocus ());
 796       if (real_focus_window)
 797         real_focus_window = gdk_window_get_toplevel (real_focus_window);
 798       if (!GDK_WINDOW_DESTROYED (k_grab_window))
 799         grab_focus_window = gdk_window_get_toplevel (k_grab_window);
 800       else
 801         grab_focus_window = NULL;
 802       if (real_focus_window != grab_focus_window)
 803         {
 804           /* Generate events for focus change from grabber to the window that
 805            * really has focus. Important for example if a new window is created
 806            * while focus is grabbed.
 807            */
 808           if (grab_focus_window
 809               && (((GdkWindowObject *) grab_focus_window)->event_mask
 810                   & GDK_FOCUS_CHANGE_MASK))
 811             generate_focus_event (grab_focus_window, FALSE);
 812
 813           if (real_focus_window && !GDK_WINDOW_DESTROYED (real_focus_window)
 814               && (((GdkWindowObject *) real_focus_window)->event_mask
 815                   & GDK_FOCUS_CHANGE_MASK))
 816             generate_focus_event (real_focus_window, TRUE);
 817         }
 818     }
 819
 820   k_grab_window = NULL;
 821 }
 822
 823 gboolean
 824 gdk_keyboard_grab_info_libgtk_only (GdkDisplay *display,
 825                                     GdkWindow **grab_window,
 826                                     gboolean   *owner_events)
 827 {
 828   g_return_val_if_fail (display == gdk_display_get_default (), FALSE);
 829
 830   if (k_grab_window)
 831     {
 832       if (grab_window)
 833         *grab_window = k_grab_window;
 834       if (owner_events)
 835         *owner_events = k_grab_owner_events;
 836
 837       return TRUE;
 838     }
 839   else
 840     return FALSE;
 841 }
 842
 843 static GdkFilterReturn
 844 gdk_event_apply_filters (MSG      *msg,
 845                          GdkEvent *event,
 846                          GList    *filters)
 847 {
 848   GdkEventFilter *filter;
 849   GList *tmp_list;
 850   GdkFilterReturn result;
 851
 852   tmp_list = filters;
 853
 854   while (tmp_list)
 855     {
 856       filter = (GdkEventFilter *) tmp_list->data;
 857
 858       result = (*filter->function) (msg, event, filter->data);
 859       if (result !=  GDK_FILTER_CONTINUE)
 860         return result;
 861
 862       tmp_list = tmp_list->next;
 863     }
 864
 865   return GDK_FILTER_CONTINUE;
 866 }
 867
 868 void
 869 gdk_display_add_client_message_filter (GdkDisplay   *display,
 870                                        GdkAtom       message_type,
 871                                        GdkFilterFunc func,
 872                                        gpointer      data)
 873 {
 874   /* XXX */
 875   gdk_add_client_message_filter (message_type, func, data);
 876 }
 877
 878 void
 879 gdk_add_client_message_filter (GdkAtom       message_type,
 880                                GdkFilterFunc func,
 881                                gpointer      data)
 882 {
 883   GdkClientFilter *filter = g_new (GdkClientFilter, 1);
 884
 885   filter->type = message_type;
 886   filter->function = func;
 887   filter->data = data;
 888
 889   client_filters = g_list_append (client_filters, filter);
 890 }
 891
 892 static void
 893 build_key_event_state (GdkEvent *event,
 894                        BYTE     *key_state)
 895 {
 896   event->key.state = 0;
 897
 898   if (key_state[VK_SHIFT] & 0x80)
 899     event->key.state |= GDK_SHIFT_MASK;
 900
 901   if (key_state[VK_CAPITAL] & 0x01)
 902     event->key.state |= GDK_LOCK_MASK;
 903
 904   if (key_state[VK_LBUTTON] & 0x80)
 905     event->key.state |= GDK_BUTTON1_MASK;
 906   if (key_state[VK_MBUTTON] & 0x80)
 907     event->key.state |= GDK_BUTTON2_MASK;
 908   if (key_state[VK_RBUTTON] & 0x80)
 909     event->key.state |= GDK_BUTTON3_MASK;
 910   if (key_state[VK_XBUTTON1] & 0x80)
 911     event->key.state |= GDK_BUTTON4_MASK;
 912   if (key_state[VK_XBUTTON2] & 0x80)
 913     event->key.state |= GDK_BUTTON5_MASK;
 914
 915   /* Win9x doesn't distinguish between left and right Control and Alt
 916    * in the keyboard state as returned by GetKeyboardState(), so we
 917    * have to punt, and accept either Control + either Alt to be AltGr.
 918    *
 919    * Alternatively, we could have some state saved when the Control
 920    * and Alt keys messages come in, as the KF_EXTENDED bit in lParam
 921    * does indicate correctly whether it is the right Control or Alt
 922    * key. But that would be a bit messy.
 923    */
 924   if (!G_WIN32_IS_NT_BASED () &&
 925       _gdk_keyboard_has_altgr &&
 926       key_state[VK_CONTROL] & 0x80 &&
 927       key_state[VK_MENU] & 0x80)
 928     key_state[VK_LCONTROL] = key_state[VK_RMENU] = 0x80;
 929
 930   if (_gdk_keyboard_has_altgr &&
 931       (key_state[VK_LCONTROL] & 0x80) &&
 932       (key_state[VK_RMENU] & 0x80))
 933     {
 934       event->key.group = 1;
 935       event->key.state |= GDK_MOD2_MASK;
 936       if (key_state[VK_RCONTROL] & 0x80)
 937         event->key.state |= GDK_CONTROL_MASK;
 938       if (key_state[VK_LMENU] & 0x80)
 939         event->key.state |= GDK_MOD1_MASK;
 940     }
 941   else
 942     {
 943       event->key.group = 0;
 944       if (key_state[VK_CONTROL] & 0x80)
 945         event->key.state |= GDK_CONTROL_MASK;
 946       if (key_state[VK_MENU] & 0x80)
 947         event->key.state |= GDK_MOD1_MASK;
 948     }
 949 }
 950
 951 static gint
 952 build_pointer_event_state (MSG *msg)
 953 {
 954   gint state;
 955
 956   state = 0;
 957
 958   if (msg->wParam & MK_CONTROL)
 959     state |= GDK_CONTROL_MASK;
 960
 961   if ((msg->message != WM_LBUTTONDOWN &&
 962        (msg->wParam & MK_LBUTTON)) ||
 963       msg->message == WM_LBUTTONUP)
 964     state |= GDK_BUTTON1_MASK;
 965
 966   if ((msg->message != WM_MBUTTONDOWN &&
 967        (msg->wParam & MK_MBUTTON)) ||
 968       msg->message == WM_MBUTTONUP)
 969     state |= GDK_BUTTON2_MASK;
 970
 971   if ((msg->message != WM_RBUTTONDOWN &&
 972        (msg->wParam & MK_RBUTTON)) ||
 973       msg->message == WM_RBUTTONUP)
 974     state |= GDK_BUTTON3_MASK;
 975
 976   if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON1) &&
 977        (msg->wParam & MK_XBUTTON1)) ||
 978       (msg->message == WM_XBUTTONUP && HIWORD (msg->wParam) == XBUTTON1))
 979     state |= GDK_BUTTON4_MASK;
 980
 981   if (((msg->message != WM_XBUTTONDOWN || HIWORD (msg->wParam) != XBUTTON2) &&
 982        (msg->wParam & MK_XBUTTON2)) ||
 983       (msg->message == WM_XBUTTONUP && HIWORD (msg->wParam) == XBUTTON2))
 984     state |= GDK_BUTTON5_MASK;
 985
 986   if (msg->wParam & MK_SHIFT)
 987     state |= GDK_SHIFT_MASK;
 988
 989   if (GetKeyState (VK_MENU) < 0)
 990     state |= GDK_MOD1_MASK;
 991
 992   if (GetKeyState (VK_CAPITAL) & 0x1)
 993     state |= GDK_LOCK_MASK;
 994
 995   return state;
 996 }
 997
 998 static void
 999 build_wm_ime_composition_event (GdkEvent *event,
1000                                 MSG      *msg,
1001                                 wchar_t   wc,
1002                                 BYTE     *key_state)
1003 {
1004   event->key.time = _gdk_win32_get_next_tick (msg->time);
1005
1006   build_key_event_state (event, key_state);
1007
1008   event->key.hardware_keycode = 0; /* FIXME: What should it be? */
1009   event->key.string = NULL;
1010   event->key.length = 0;
1011   event->key.keyval = gdk_unicode_to_keyval (wc);
1012 }
1013
1014 #ifdef G_ENABLE_DEBUG
1015
1016 static void
1017 print_event_state (guint state)
1018 {
1019 #define CASE(bit) if (state & GDK_ ## bit ## _MASK) g_print (#bit " ");
1020   CASE (SHIFT);
1021   CASE (LOCK);
1022   CASE (CONTROL);
1023   CASE (MOD1);
1024   CASE (MOD2);
1025   CASE (MOD3);
1026   CASE (MOD4);
1027   CASE (MOD5);
1028   CASE (BUTTON1);
1029   CASE (BUTTON2);
1030   CASE (BUTTON3);
1031   CASE (BUTTON4);
1032   CASE (BUTTON5);
1033 #undef CASE
1034 }
1035
1036 static void
1037 print_event (GdkEvent *event)
1038 {
1039   gchar *escaped, *kvname;
1040
1041   g_print ("%s%*s===> ", (debug_indent > 0 ? "\n" : ""), debug_indent, "");
1042   switch (event->any.type)
1043     {
1044 #define CASE(x) case x: g_print (#x); break;
1045     CASE (GDK_NOTHING);
1046     CASE (GDK_DELETE);
1047     CASE (GDK_DESTROY);
1048     CASE (GDK_EXPOSE);
1049     CASE (GDK_MOTION_NOTIFY);
1050     CASE (GDK_BUTTON_PRESS);
1051     CASE (GDK_2BUTTON_PRESS);
1052     CASE (GDK_3BUTTON_PRESS);
1053     CASE (GDK_BUTTON_RELEASE);
1054     CASE (GDK_KEY_PRESS);
1055     CASE (GDK_KEY_RELEASE);
1056     CASE (GDK_ENTER_NOTIFY);
1057     CASE (GDK_LEAVE_NOTIFY);
1058     CASE (GDK_FOCUS_CHANGE);
1059     CASE (GDK_CONFIGURE);
1060     CASE (GDK_MAP);
1061     CASE (GDK_UNMAP);
1062     CASE (GDK_PROPERTY_NOTIFY);
1063     CASE (GDK_SELECTION_CLEAR);
1064     CASE (GDK_SELECTION_REQUEST);
1065     CASE (GDK_SELECTION_NOTIFY);
1066     CASE (GDK_PROXIMITY_IN);
1067     CASE (GDK_PROXIMITY_OUT);
1068     CASE (GDK_DRAG_ENTER);
1069     CASE (GDK_DRAG_LEAVE);
1070     CASE (GDK_DRAG_MOTION);
1071     CASE (GDK_DRAG_STATUS);
1072     CASE (GDK_DROP_START);
1073     CASE (GDK_DROP_FINISHED);
1074     CASE (GDK_CLIENT_EVENT);
1075     CASE (GDK_VISIBILITY_NOTIFY);
1076     CASE (GDK_NO_EXPOSE);
1077     CASE (GDK_SCROLL);
1078     CASE (GDK_WINDOW_STATE);
1079     CASE (GDK_SETTING);
1080 #undef CASE
1081     default: g_assert_not_reached ();
1082     }
1083
1084   g_print (" %p ", GDK_WINDOW_HWND (event->any.window));
1085
1086   switch (event->any.type)
1087     {
1088     case GDK_EXPOSE:
1089       g_print ("%s %d",
1090                _gdk_win32_gdkrectangle_to_string (&event->expose.area),
1091                event->expose.count);
1092       break;
1093     case GDK_MOTION_NOTIFY:
1094       g_print ("(%.4g,%.4g) (%.4g,%.4g) %s",
1095                event->motion.x, event->motion.y,
1096                event->motion.x_root, event->motion.y_root,
1097                event->motion.is_hint ? "HINT " : "");
1098       print_event_state (event->motion.state);
1099       break;
1100     case GDK_BUTTON_PRESS:
1101     case GDK_2BUTTON_PRESS:
1102     case GDK_3BUTTON_PRESS:
1103     case GDK_BUTTON_RELEASE:
1104       g_print ("%d (%.4g,%.4g) (%.4g,%.4g) ",
1105                event->button.button,
1106                event->button.x, event->button.y,
1107                event->button.x_root, event->button.y_root);
1108       print_event_state (event->button.state);
1109       break;
1110     case GDK_KEY_PRESS:
1111     case GDK_KEY_RELEASE:
1112       if (event->key.length == 0)
1113         escaped = g_strdup ("");
1114       else
1115         escaped = g_strescape (event->key.string, NULL);
1116       kvname = gdk_keyval_name (event->key.keyval);
1117       g_print ("%#.02x group:%d %s %d:\"%s\" ",
1118                event->key.hardware_keycode, event->key.group,
1119                (kvname ? kvname : "??"),
1120                event->key.length,
1121                escaped);
1122       g_free (escaped);
1123       print_event_state (event->key.state);
1124       break;
1125     case GDK_ENTER_NOTIFY:
1126     case GDK_LEAVE_NOTIFY:
1127       g_print ("%p (%.4g,%.4g) (%.4g,%.4g) %s %s%s",
1128                event->crossing.subwindow == NULL ? NULL : GDK_WINDOW_HWND (event->crossing.subwindow),
1129                event->crossing.x, event->crossing.y,
1130                event->crossing.x_root, event->crossing.y_root,
1131                (event->crossing.mode == GDK_CROSSING_NORMAL ? "NORMAL" :
1132                 (event->crossing.mode == GDK_CROSSING_GRAB ? "GRAB" :
1133                  (event->crossing.mode == GDK_CROSSING_UNGRAB ? "UNGRAB" :
1134                   "???"))),
1135                (event->crossing.detail == GDK_NOTIFY_ANCESTOR ? "ANCESTOR" :
1136                 (event->crossing.detail == GDK_NOTIFY_VIRTUAL ? "VIRTUAL" :
1137                  (event->crossing.detail == GDK_NOTIFY_INFERIOR ? "INFERIOR" :
1138                   (event->crossing.detail == GDK_NOTIFY_NONLINEAR ? "NONLINEAR" :
1139                    (event->crossing.detail == GDK_NOTIFY_NONLINEAR_VIRTUAL ? "NONLINEAR_VIRTUAL" :
1140                     (event->crossing.detail == GDK_NOTIFY_UNKNOWN ? "UNKNOWN" :
1141                      "???")))))),
1142                event->crossing.focus ? " FOCUS" : "");
1143       print_event_state (event->crossing.state);
1144       break;
1145     case GDK_FOCUS_CHANGE:
1146       g_print ("%s", (event->focus_change.in ? "IN" : "OUT"));
1147       break;
1148     case GDK_CONFIGURE:
1149       g_print ("x:%d y:%d w:%d h:%d",
1150                event->configure.x, event->configure.y,
1151                event->configure.width, event->configure.height);
1152       break;
1153     case GDK_SCROLL:
1154       g_print ("(%.4g,%.4g) (%.4g,%.4g) %s ",
1155                event->scroll.x, event->scroll.y,
1156                event->scroll.x_root, event->scroll.y_root,
1157                (event->scroll.direction == GDK_SCROLL_UP ? "UP" :
1158                 (event->scroll.direction == GDK_SCROLL_DOWN ? "DOWN" :
1159                  (event->scroll.direction == GDK_SCROLL_LEFT ? "LEFT" :
1160                   (event->scroll.direction == GDK_SCROLL_RIGHT ? "RIGHT" :
1161                    "???")))));
1162       print_event_state (event->scroll.state);
1163       break;
1164     case GDK_WINDOW_STATE:
1165       g_print ("%s: %s",
1166                _gdk_win32_window_state_to_string (event->window_state.changed_mask),
1167                _gdk_win32_window_state_to_string (event->window_state.new_window_state));
1168     default:
1169       /* Nothing */
1170       break;
1171     }
1172   g_print ("%s", (debug_indent == 0 ? "\n" : ""));
1173 }
1174
1175 static char *
1176 decode_key_lparam (LPARAM lParam)
1177 {
1178   static char buf[100];
1179   char *p = buf;
1180
1181   if (HIWORD (lParam) & KF_UP)
1182     p += g_sprintf (p, "KF_UP ");
1183   if (HIWORD (lParam) & KF_REPEAT)
1184     p += g_sprintf (p, "KF_REPEAT ");
1185   if (HIWORD (lParam) & KF_ALTDOWN)
1186     p += g_sprintf (p, "KF_ALTDOWN ");
1187   if (HIWORD (lParam) & KF_EXTENDED)
1188     p += g_sprintf (p, "KF_EXTENDED ");
1189   p += g_sprintf (p, "sc:%d rep:%d", LOBYTE (HIWORD (lParam)), LOWORD (lParam));
1190
1191   return buf;
1192 }
1193
1194 #endif
1195
1196 static void
1197 fixup_event (GdkEvent *event)
1198 {
1199   if (event->any.window)
1200     g_object_ref (event->any.window);
1201   if (((event->any.type == GDK_ENTER_NOTIFY) ||
1202        (event->any.type == GDK_LEAVE_NOTIFY)) &&
1203       (event->crossing.subwindow != NULL))
1204     g_object_ref (event->crossing.subwindow);
1205   event->any.send_event = InSendMessage ();
1206 }
1207
1208 static void
1209 append_event (GdkDisplay *display,
1210               GdkEvent   *event)
1211 {
1212   fixup_event (event);
1213   _gdk_event_queue_append (display, event);
1214   GDK_NOTE (EVENTS, print_event (event));
1215 }
1216
1217 static void
1218 fill_key_event_string (GdkEvent *event)
1219 {
1220   gunichar c;
1221   gchar buf[256];
1222
1223   /* Fill in event->string crudely, since various programs
1224    * depend on it.
1225    */
1226
1227   c = 0;
1228   if (event->key.keyval != GDK_VoidSymbol)
1229     c = gdk_keyval_to_unicode (event->key.keyval);
1230
1231   if (c)
1232     {
1233       gsize bytes_written;
1234       gint len;
1235
1236       /* Apply the control key - Taken from Xlib
1237        */
1238       if (event->key.state & GDK_CONTROL_MASK)
1239         {
1240           if ((c >= '@' && c < '\177') || c == ' ')
1241             c &= 0x1F;
1242           else if (c == '2')
1243             {
1244               event->key.string = g_memdup ("\0\0", 2);
1245               event->key.length = 1;
1246               return;
1247             }
1248           else if (c >= '3' && c <= '7')
1249             c -= ('3' - '\033');
1250           else if (c == '8')
1251             c = '\177';
1252           else if (c == '/')
1253             c = '_' & 0x1F;
1254         }
1255
1256       len = g_unichar_to_utf8 (c, buf);
1257       buf[len] = '\0';
1258
1259       event->key.string = g_locale_from_utf8 (buf, len,
1260                                               NULL, &bytes_written,
1261                                               NULL);
1262       if (event->key.string)
1263         event->key.length = bytes_written;
1264     }
1265   else if (event->key.keyval == GDK_Escape)
1266     {
1267       event->key.length = 1;
1268       event->key.string = g_strdup ("\033");
1269     }
1270   else if (event->key.keyval == GDK_Return ||
1271            event->key.keyval == GDK_KP_Enter)
1272     {
1273       event->key.length = 1;
1274       event->key.string = g_strdup ("\r");
1275     }
1276
1277   if (!event->key.string)
1278     {
1279       event->key.length = 0;
1280       event->key.string = g_strdup ("");
1281     }
1282 }
1283
1284 static GdkFilterReturn
1285 apply_filters (GdkDisplay *display,
1286                GdkWindow  *window,
1287                MSG        *msg,
1288                GList      *filters)
1289 {
1290   GdkFilterReturn result;
1291   GdkEvent *event = gdk_event_new (GDK_NOTHING);
1292   GList *node;
1293
1294   if (window != NULL)
1295     {
1296       event->any.window = window;
1297       g_object_ref (window);
1298     }
1299   ((GdkEventPrivate *)event)->flags |= GDK_EVENT_PENDING;
1300
1301   /* I think GdkFilterFunc semantics require the passed-in event
1302    * to already be in the queue. The filter func can generate
1303    * more events and append them after it if it likes.
1304    */
1305   node = _gdk_event_queue_append (display, event);
1306
1307   result = gdk_event_apply_filters (msg, event, filters);
1308
1309   if (result == GDK_FILTER_CONTINUE || result == GDK_FILTER_REMOVE)
1310     {
1311       _gdk_event_queue_remove_link (display, node);
1312       g_list_free_1 (node);
1313       gdk_event_free (event);
1314     }
1315   else /* GDK_FILTER_TRANSLATE */
1316     {
1317       ((GdkEventPrivate *)event)->flags &= ~GDK_EVENT_PENDING;
1318       fixup_event (event);
1319       GDK_NOTE (EVENTS, print_event (event));
1320     }
1321   return result;
1322 }
1323
1324 static gboolean
1325 gdk_window_is_ancestor (GdkWindow *ancestor,
1326                         GdkWindow *window)
1327 {
1328   if (ancestor == NULL || window == NULL)
1329     return FALSE;
1330
1331   return (gdk_window_get_parent (window) == ancestor ||
1332           gdk_window_is_ancestor (ancestor, gdk_window_get_parent (window)));
1333 }
1334
1335 static void
1336 synthesize_enter_or_leave_event (GdkWindow      *window,
1337                                  MSG            *msg,
1338                                  GdkEventType    type,
1339                                  GdkCrossingMode mode,
1340                                  GdkNotifyType detail,
1341                                  gint            x,
1342                                  gint            y)
1343 {
1344   GdkEvent *event;
1345   gint xoffset, yoffset;
1346
1347   event = gdk_event_new (type);
1348   event->crossing.window = window;
1349   event->crossing.subwindow = NULL;
1350   event->crossing.time = _gdk_win32_get_next_tick (msg->time);
1351   _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
1352   event->crossing.x = x + xoffset;
1353   event->crossing.y = y + yoffset;
1354   event->crossing.x_root = msg->pt.x + _gdk_offset_x;
1355   event->crossing.y_root = msg->pt.y + _gdk_offset_y;
1356   event->crossing.mode = mode;
1357   event->crossing.detail = detail;
1358   event->crossing.focus = TRUE; /* FIXME: Set correctly */
1359   event->crossing.state = 0;    /* FIXME: Set correctly */
1360
1361   append_event (gdk_drawable_get_display (window), event);
1362
1363   if (type == GDK_ENTER_NOTIFY &&
1364       ((GdkWindowObject *) window)->extension_events != 0)
1365     _gdk_input_enter_event (window);
1366 }
1367
1368 static void
1369 synthesize_leave_event (GdkWindow      *window,
1370                         MSG            *msg,
1371                         GdkCrossingMode mode,
1372                         GdkNotifyType   detail)
1373 {
1374   POINT pt;
1375
1376   if (p_grab_window != NULL && !p_grab_owner_events && !(p_grab_mask & GDK_LEAVE_NOTIFY_MASK))
1377     return;
1378
1379   if (!(((GdkWindowObject *) window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
1380     return;
1381
1382   /* Leave events are at (current_x,current_y) in current_window */
1383
1384   if (current_window != window)
1385     {
1386       pt.x = current_x;
1387       pt.y = current_y;
1388       ClientToScreen (GDK_WINDOW_HWND (current_window), &pt);
1389       ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1390       synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, mode, detail, pt.x, pt.y);
1391     }
1392   else
1393     synthesize_enter_or_leave_event (window, msg, GDK_LEAVE_NOTIFY, mode, detail, current_x, current_y);
1394
1395   /* This would only make sense if the WM_MOUSEMOVE messages would come
1396    * before the respective WM_MOUSELEAVE message, which apparently they
1397    * do not.
1398   track_mouse_event (TME_CANCEL, msg->hwnd);
1399    */
1400 }
1401
1402 static void
1403 synthesize_enter_event (GdkWindow      *window,
1404                         MSG            *msg,
1405                         GdkCrossingMode mode,
1406                         GdkNotifyType   detail)
1407 {
1408   POINT pt;
1409
1410   if (p_grab_window != NULL && !p_grab_owner_events && !(p_grab_mask & GDK_ENTER_NOTIFY_MASK))
1411     return;
1412
1413   if (!(((GdkWindowObject *) window)->event_mask & GDK_ENTER_NOTIFY_MASK))
1414     return;
1415
1416   /* Enter events are at GET_X_LPARAM (msg->lParam), GET_Y_LPARAM
1417    * (msg->lParam) in msg->hwnd
1418    */
1419
1420   pt.x = GET_X_LPARAM (msg->lParam);
1421   pt.y = GET_Y_LPARAM (msg->lParam);
1422   if (msg->hwnd != GDK_WINDOW_HWND (window))
1423     {
1424       ClientToScreen (msg->hwnd, &pt);
1425       ScreenToClient (GDK_WINDOW_HWND (window), &pt);
1426     }
1427   synthesize_enter_or_leave_event (window, msg, GDK_ENTER_NOTIFY, mode, detail, pt.x, pt.y);
1428
1429   track_mouse_event (TME_LEAVE, GDK_WINDOW_HWND (window));
1430 }
1431
1432 static void
1433 synthesize_enter_events (GdkWindow      *from,
1434                          GdkWindow      *to,
1435                          MSG            *msg,
1436                          GdkCrossingMode mode,
1437                          GdkNotifyType   detail)
1438 {
1439   GdkWindow *prev = gdk_window_get_parent (to);
1440
1441   if (prev != from)
1442     synthesize_enter_events (from, prev, msg, mode, detail);
1443   synthesize_enter_event (to, msg, mode, detail);
1444 }
1445
1446 static void
1447 synthesize_leave_events (GdkWindow      *from,
1448                          GdkWindow      *to,
1449                          MSG            *msg,
1450                          GdkCrossingMode mode,
1451                          GdkNotifyType   detail)
1452 {
1453   GdkWindow *next = gdk_window_get_parent (from);
1454
1455   synthesize_leave_event (from, msg, mode, detail);
1456   if (next != to)
1457     synthesize_leave_events (next, to, msg, mode, detail);
1458 }
1459
1460 static void
1461 synthesize_crossing_events (GdkWindow      *window,
1462                             GdkCrossingMode mode,
1463                             MSG            *msg)
1464 {
1465   GdkWindow *intermediate, *tem, *common_ancestor;
1466
1467   if (gdk_window_is_ancestor (current_window, window))
1468     {
1469       /* Pointer has moved to an inferior window. */
1470       synthesize_leave_event (current_window, msg, mode, GDK_NOTIFY_INFERIOR);
1471
1472       /* If there are intermediate windows, generate ENTER_NOTIFY
1473        * events for them
1474        */
1475       intermediate = gdk_window_get_parent (window);
1476       if (intermediate != current_window)
1477         {
1478           synthesize_enter_events (current_window, intermediate, msg, mode, GDK_NOTIFY_VIRTUAL);
1479         }
1480
1481       synthesize_enter_event (window, msg, mode, GDK_NOTIFY_ANCESTOR);
1482     }
1483   else if (gdk_window_is_ancestor (window, current_window))
1484     {
1485       /* Pointer has moved to an ancestor window. */
1486       synthesize_leave_event (current_window, msg, mode, GDK_NOTIFY_ANCESTOR);
1487
1488       /* If there are intermediate windows, generate LEAVE_NOTIFY
1489        * events for them
1490        */
1491       intermediate = gdk_window_get_parent (current_window);
1492       if (intermediate != window)
1493         {
1494           synthesize_leave_events (intermediate, window, msg, mode, GDK_NOTIFY_VIRTUAL);
1495         }
1496
1497       synthesize_enter_event (window, msg, mode, GDK_NOTIFY_INFERIOR);
1498     }
1499   else if (current_window)
1500     {
1501       /* Find least common ancestor of current_window and window */
1502       tem = current_window;
1503       do {
1504         common_ancestor = gdk_window_get_parent (tem);
1505         tem = common_ancestor;
1506       } while (common_ancestor &&
1507                !gdk_window_is_ancestor (common_ancestor, window));
1508       if (common_ancestor)
1509         {
1510           synthesize_leave_event (current_window, msg, mode, GDK_NOTIFY_NONLINEAR);
1511           intermediate = gdk_window_get_parent (current_window);
1512           if (intermediate != common_ancestor)
1513             {
1514               synthesize_leave_events (intermediate, common_ancestor,
1515                                        msg, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1516             }
1517           intermediate = gdk_window_get_parent (window);
1518           if (intermediate != common_ancestor)
1519             {
1520               synthesize_enter_events (common_ancestor, intermediate,
1521                                        msg, mode, GDK_NOTIFY_NONLINEAR_VIRTUAL);
1522             }
1523           synthesize_enter_event (window, msg, mode, GDK_NOTIFY_NONLINEAR);
1524         }
1525     }
1526   else
1527     {
1528       /* Dunno where we are coming from */
1529       synthesize_enter_event (window, msg, mode, GDK_NOTIFY_UNKNOWN);
1530     }
1531
1532   assign_object (&current_window, window);
1533 }
1534
1535 static void
1536 synthesize_expose_events (GdkWindow *window)
1537 {
1538   RECT r;
1539   HDC hdc;
1540   GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
1541   GList *list = gdk_window_get_children (window);
1542   GList *head = list;
1543   GdkEvent *event;
1544   int k;
1545
1546   while (list)
1547     {
1548       synthesize_expose_events ((GdkWindow *) list->data);
1549       list = list->next;
1550     }
1551
1552   g_list_free (head);
1553
1554   if (((GdkWindowObject *) window)->input_only)
1555     ;
1556   else if (!(hdc = GetDC (impl->handle)))
1557     WIN32_GDI_FAILED ("GetDC");
1558   else
1559     {
1560       if ((k = GetClipBox (hdc, &r)) == ERROR)
1561         WIN32_GDI_FAILED ("GetClipBox");
1562       else if (k != NULLREGION)
1563         {
1564           event = gdk_event_new (GDK_EXPOSE);
1565           event->expose.window = window;
1566           event->expose.area.x = r.left;
1567           event->expose.area.y = r.top;
1568           event->expose.area.width = r.right - r.left;
1569           event->expose.area.height = r.bottom - r.top;
1570           event->expose.region = gdk_region_rectangle (&(event->expose.area));
1571           event->expose.count = 0;
1572
1573           append_event (gdk_drawable_get_display (window), event);
1574         }
1575       GDI_CALL (ReleaseDC, (impl->handle, hdc));
1576     }
1577 }
1578
1579 static void
1580 update_colors (GdkWindow *window,
1581                gboolean   top)
1582 {
1583   HDC hdc;
1584   GdkDrawableImplWin32 *impl = GDK_DRAWABLE_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
1585   GList *list = gdk_window_get_children (window);
1586   GList *head = list;
1587
1588   GDK_NOTE (COLORMAP, (top ? g_print ("update_colors:") : (void) 0));
1589
1590   while (list)
1591     {
1592       update_colors ((GdkWindow *) list->data, FALSE);
1593       list = list->next;
1594     }
1595   g_list_free (head);
1596
1597   if (((GdkWindowObject *) window)->input_only ||
1598       impl->colormap == NULL)
1599     return;
1600
1601   if (!(hdc = GetDC (impl->handle)))
1602     WIN32_GDI_FAILED ("GetDC");
1603   else
1604     {
1605       GdkColormapPrivateWin32 *cmapp = GDK_WIN32_COLORMAP_DATA (impl->colormap);
1606       HPALETTE holdpal;
1607       gint k;
1608
1609       if ((holdpal = SelectPalette (hdc, cmapp->hpal, TRUE)) == NULL)
1610         WIN32_GDI_FAILED ("SelectPalette");
1611       else if ((k = RealizePalette (hdc)) == GDI_ERROR)
1612         WIN32_GDI_FAILED ("RealizePalette");
1613       else
1614         {
1615           GDK_NOTE (COLORMAP,
1616                     (k > 0 ?
1617                      g_print (" %p pal=%p: realized %d colors\n"
1618                               "update_colors:",
1619                               impl->handle, cmapp->hpal, k) :
1620                      (void) 0,
1621                      g_print (" %p", impl->handle)));
1622           GDI_CALL (UpdateColors, (hdc));
1623           SelectPalette (hdc, holdpal, TRUE);
1624           RealizePalette (hdc);
1625         }
1626       GDI_CALL (ReleaseDC, (impl->handle, hdc));
1627     }
1628   GDK_NOTE (COLORMAP, (top ? g_print ("\n") : (void) 0));
1629 }
1630
1631 static void
1632 translate_mouse_coords (GdkWindow *window1,
1633                         GdkWindow *window2,
1634                         MSG       *msg)
1635 {
1636   POINT pt;
1637
1638   pt.x = GET_X_LPARAM (msg->lParam);
1639   pt.y = GET_Y_LPARAM (msg->lParam);
1640   ClientToScreen (GDK_WINDOW_HWND (window1), &pt);
1641   ScreenToClient (GDK_WINDOW_HWND (window2), &pt);
1642   msg->lParam = MAKELPARAM (pt.x, pt.y);
1643 }
1644
1645 /* The check_extended flag controls whether to check if the windows want
1646  * events from extended input devices and if the message should be skipped
1647  * because an extended input device is active */
1648 static gboolean
1649 propagate (GdkWindow  **window,
1650            MSG         *msg,
1651            GdkWindow   *grab_window,
1652            gboolean     grab_owner_events,
1653            gint         grab_mask,
1654            gboolean   (*doesnt_want_it) (gint mask,
1655                                          MSG *msg),
1656            gboolean     check_extended)
1657 {
1658   gboolean in_propagation = FALSE;
1659
1660   if (grab_window != NULL && !grab_owner_events)
1661     {
1662       /* Event source is grabbed with owner_events FALSE */
1663
1664       /* See if the event should be ignored because an extended input device
1665        * is used */
1666       if (check_extended &&
1667           ((GdkWindowObject *) grab_window)->extension_events != 0 &&
1668           _gdk_input_ignore_core)
1669         {
1670           GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
1671           return FALSE;
1672         }
1673       if ((*doesnt_want_it) (grab_mask, msg))
1674         {
1675           GDK_NOTE (EVENTS, g_print (" (grabber doesn't want it)"));
1676           return FALSE;
1677         }
1678       else
1679         {
1680           GDK_NOTE (EVENTS, g_print (" (to grabber)"));
1681           assign_object (window, grab_window);
1682           return TRUE;
1683         }
1684     }
1685   while (TRUE)
1686     {
1687       /* See if the event should be ignored because an extended input device
1688        * is used */
1689       if (check_extended &&
1690           ((GdkWindowObject *) *window)->extension_events != 0 &&
1691           _gdk_input_ignore_core)
1692         {
1693           GDK_NOTE (EVENTS, g_print (" (ignored)"));
1694           return FALSE;
1695         }
1696       if ((*doesnt_want_it) (((GdkWindowObject *) *window)->event_mask, msg))
1697         {
1698           /* Owner doesn't want it, propagate to parent. */
1699           GdkWindow *parent = gdk_window_get_parent (*window);
1700           if (parent == _gdk_root || parent == NULL)
1701             {
1702               /* No parent; check if grabbed */
1703               if (grab_window != NULL)
1704                 {
1705                   /* Event source is grabbed with owner_events TRUE */
1706
1707                   /* See if the event should be ignored because an extended
1708                    * input device is used */
1709                   if (check_extended &&
1710                       ((GdkWindowObject *) grab_window)->extension_events != 0 &&
1711                       _gdk_input_ignore_core)
1712                     {
1713                       GDK_NOTE (EVENTS, g_print (" (ignored for grabber)"));
1714                       return FALSE;
1715                     }
1716                   if ((*doesnt_want_it) (grab_mask, msg))
1717                     {
1718                       /* Grabber doesn't want it either */
1719                       GDK_NOTE (EVENTS, g_print (" (grabber doesn't want it)"));
1720                       return FALSE;
1721                     }
1722                   else
1723                     {
1724                       /* Grabbed! */
1725                       GDK_NOTE (EVENTS, g_print (" (to grabber)"));
1726                       assign_object (window, grab_window);
1727                       return TRUE;
1728                     }
1729                 }
1730               else
1731                 {
1732                   GDK_NOTE (EVENTS, g_print (" (undelivered)"));
1733                   return FALSE;
1734                 }
1735             }
1736           else
1737             {
1738               assign_object (window, parent);
1739               in_propagation = TRUE;
1740               /* The only branch where we actually continue the loop */
1741             }
1742         }
1743       else
1744         return TRUE;
1745     }
1746 }
1747
1748 static gboolean
1749 doesnt_want_key (gint mask,
1750                  MSG *msg)
1751 {
1752   return (((msg->message == WM_KEYUP || msg->message == WM_SYSKEYUP) &&
1753            !(mask & GDK_KEY_RELEASE_MASK)) ||
1754           ((msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN) &&
1755            !(mask & GDK_KEY_PRESS_MASK)));
1756 }
1757
1758 static gboolean
1759 doesnt_want_char (gint mask,
1760                   MSG *msg)
1761 {
1762   return !(mask & (GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK));
1763 }
1764
1765 static gboolean
1766 doesnt_want_button_press (gint mask,
1767                           MSG *msg)
1768 {
1769   return !(mask & GDK_BUTTON_PRESS_MASK);
1770 }
1771
1772 static gboolean
1773 doesnt_want_button_release (gint mask,
1774                             MSG *msg)
1775 {
1776   return !(mask & GDK_BUTTON_RELEASE_MASK);
1777 }
1778
1779 static gboolean
1780 doesnt_want_button_motion (gint mask,
1781                            MSG *msg)
1782 {
1783   return !((mask & GDK_POINTER_MOTION_MASK) ||
1784            ((msg->wParam & (MK_LBUTTON|MK_MBUTTON|MK_RBUTTON)) && (mask & GDK_BUTTON_MOTION_MASK)) ||
1785            ((msg->wParam & MK_LBUTTON) && (mask & GDK_BUTTON1_MOTION_MASK)) ||
1786            ((msg->wParam & MK_MBUTTON) && (mask & GDK_BUTTON2_MOTION_MASK)) ||
1787            ((msg->wParam & MK_RBUTTON) && (mask & GDK_BUTTON3_MOTION_MASK)));
1788 }
1789
1790 static gboolean
1791 doesnt_want_scroll (gint mask,
1792                     MSG *msg)
1793 {
1794 #if 0
1795   return !(mask & GDK_SCROLL_MASK);
1796 #else
1797   return !(mask & GDK_BUTTON_PRESS_MASK);
1798 #endif
1799 }
1800
1801 static void
1802 handle_configure_event (MSG       *msg,
1803                         GdkWindow *window)
1804 {
1805   RECT client_rect;
1806   POINT point;
1807
1808   GetClientRect (msg->hwnd, &client_rect);
1809   point.x = client_rect.left; /* always 0 */
1810   point.y = client_rect.top;
1811   /* top level windows need screen coords */
1812   if (gdk_window_get_parent (window) == _gdk_root)
1813     {
1814       ClientToScreen (msg->hwnd, &point);
1815       point.x += _gdk_offset_x;
1816       point.y += _gdk_offset_y;
1817     }
1818
1819   GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->width = client_rect.right - client_rect.left;
1820   GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->height = client_rect.bottom - client_rect.top;
1821
1822   ((GdkWindowObject *) window)->x = point.x;
1823   ((GdkWindowObject *) window)->y = point.y;
1824
1825   if (((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK)
1826     {
1827       GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
1828
1829       event->configure.window = window;
1830
1831       event->configure.width = client_rect.right - client_rect.left;
1832       event->configure.height = client_rect.bottom - client_rect.top;
1833
1834       event->configure.x = point.x;
1835       event->configure.y = point.y;
1836
1837       append_event (gdk_drawable_get_display (window), event);
1838     }
1839 }
1840
1841 static void
1842 erase_background (GdkWindow *window,
1843                   HDC        hdc)
1844 {
1845   HDC bgdc = NULL;
1846   HBRUSH hbr = NULL;
1847   HPALETTE holdpal = NULL;
1848   RECT rect;
1849   COLORREF bg;
1850   GdkColormap *colormap;
1851   GdkColormapPrivateWin32 *colormap_private;
1852   int x, y;
1853   int x_offset, y_offset;
1854
1855   if (((GdkWindowObject *) window)->input_only ||
1856       ((GdkWindowObject *) window)->bg_pixmap == GDK_NO_BG ||
1857       GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg)
1858     {
1859       return;
1860     }
1861
1862   colormap = gdk_drawable_get_colormap (window);
1863
1864   if (colormap &&
1865       (colormap->visual->type == GDK_VISUAL_PSEUDO_COLOR ||
1866        colormap->visual->type == GDK_VISUAL_STATIC_COLOR))
1867     {
1868       int k;
1869
1870       colormap_private = GDK_WIN32_COLORMAP_DATA (colormap);
1871
1872       if (!(holdpal = SelectPalette (hdc,  colormap_private->hpal, FALSE)))
1873         WIN32_GDI_FAILED ("SelectPalette");
1874       else if ((k = RealizePalette (hdc)) == GDI_ERROR)
1875         WIN32_GDI_FAILED ("RealizePalette");
1876       else if (k > 0)
1877         GDK_NOTE (COLORMAP, g_print ("erase_background: realized %p: %d colors\n",
1878                                      colormap_private->hpal, k));
1879     }
1880
1881   x_offset = y_offset = 0;
1882   while (window && ((GdkWindowObject *) window)->bg_pixmap == GDK_PARENT_RELATIVE_BG)
1883     {
1884       /* If this window should have the same background as the parent,
1885        * fetch the parent. (And if the same goes for the parent, fetch
1886        * the grandparent, etc.)
1887        */
1888       x_offset += ((GdkWindowObject *) window)->x;
1889       y_offset += ((GdkWindowObject *) window)->y;
1890       window = GDK_WINDOW (((GdkWindowObject *) window)->parent);
1891     }
1892
1893   if (GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->position_info.no_bg)
1894     {
1895       /* Improves scolling effect, e.g. main buttons of testgtk */
1896       return;
1897     }
1898
1899   GetClipBox (hdc, &rect);
1900
1901   if (((GdkWindowObject *) window)->bg_pixmap == NULL)
1902     {
1903       bg = _gdk_win32_colormap_color (GDK_DRAWABLE_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->colormap,
1904                                       ((GdkWindowObject *) window)->bg_color.pixel);
1905
1906       if (!(hbr = CreateSolidBrush (bg)))
1907         WIN32_GDI_FAILED ("CreateSolidBrush");
1908       else if (!FillRect (hdc, &rect, hbr))
1909         WIN32_GDI_FAILED ("FillRect");
1910       if (hbr != NULL)
1911         DeleteObject (hbr);
1912     }
1913   else if (((GdkWindowObject *) window)->bg_pixmap != GDK_NO_BG)
1914     {
1915       GdkPixmap *pixmap = ((GdkWindowObject *) window)->bg_pixmap;
1916       GdkPixmapImplWin32 *pixmap_impl = GDK_PIXMAP_IMPL_WIN32 (GDK_PIXMAP_OBJECT (pixmap)->impl);
1917
1918       if (x_offset == 0 && y_offset == 0 &&
1919           pixmap_impl->width <= 8 && pixmap_impl->height <= 8)
1920         {
1921           if (!(hbr = CreatePatternBrush (GDK_PIXMAP_HBITMAP (pixmap))))
1922             WIN32_GDI_FAILED ("CreatePatternBrush");
1923           else if (!FillRect (hdc, &rect, hbr))
1924             WIN32_GDI_FAILED ("FillRect");
1925           if (hbr != NULL)
1926             DeleteObject (hbr);
1927         }
1928       else
1929         {
1930           HGDIOBJ oldbitmap;
1931
1932           if (!(bgdc = CreateCompatibleDC (hdc)))
1933             {
1934               WIN32_GDI_FAILED ("CreateCompatibleDC");
1935               return;
1936             }
1937           if (!(oldbitmap = SelectObject (bgdc, GDK_PIXMAP_HBITMAP (pixmap))))
1938             {
1939               WIN32_GDI_FAILED ("SelectObject");
1940               DeleteDC (bgdc);
1941               return;
1942             }
1943           x = -x_offset;
1944           while (x < rect.right)
1945             {
1946               if (x + pixmap_impl->width >= rect.left)
1947                 {
1948                   y = -y_offset;
1949                   while (y < rect.bottom)
1950                     {
1951                       if (y + pixmap_impl->height >= rect.top)
1952                         {
1953                           if (!BitBlt (hdc, x, y,
1954                                        pixmap_impl->width, pixmap_impl->height,
1955                                        bgdc, 0, 0, SRCCOPY))
1956                             {
1957                               WIN32_GDI_FAILED ("BitBlt");
1958                               SelectObject (bgdc, oldbitmap);
1959                               DeleteDC (bgdc);
1960                               return;
1961                             }
1962                         }
1963                       y += pixmap_impl->height;
1964                     }
1965                 }
1966               x += pixmap_impl->width;
1967             }
1968           SelectObject (bgdc, oldbitmap);
1969           DeleteDC (bgdc);
1970         }
1971     }
1972 }
1973
1974 static GdkRegion *
1975 _gdk_win32_hrgn_to_region (HRGN hrgn)
1976 {
1977   RGNDATA *rgndata;
1978   RECT *rects;
1979   GdkRegion *result;
1980   gint nbytes;
1981   guint i;
1982
1983   if ((nbytes = GetRegionData (hrgn, 0, NULL)) == 0)
1984     {
1985       WIN32_GDI_FAILED ("GetRegionData");
1986       return NULL;
1987     }
1988
1989   rgndata = (RGNDATA *) g_malloc (nbytes);
1990
1991   if (GetRegionData (hrgn, nbytes, rgndata) == 0)
1992     {
1993       WIN32_GDI_FAILED ("GetRegionData");
1994       g_free (rgndata);
1995       return NULL;
1996     }
1997
1998   result = gdk_region_new ();
1999   rects = (RECT *) rgndata->Buffer;
2000   for (i = 0; i < rgndata->rdh.nCount; i++)
2001     {
2002       GdkRectangle r;
2003
2004       r.x = rects[i].left;
2005       r.y = rects[i].top;
2006       r.width = rects[i].right - r.x;
2007       r.height = rects[i].bottom - r.y;
2008
2009       gdk_region_union_with_rect (result, &r);
2010     }
2011
2012   g_free (rgndata);
2013
2014   return result;
2015 }
2016
2017 static void
2018 adjust_drag (LONG *drag,
2019              LONG  curr,
2020              gint  inc)
2021 {
2022   if (*drag > curr)
2023     *drag = curr + ((*drag + inc/2 - curr) / inc) * inc;
2024   else
2025     *drag = curr - ((curr - *drag + inc/2) / inc) * inc;
2026 }
2027
2028 static void
2029 handle_wm_paint (MSG        *msg,
2030                  GdkWindow  *window,
2031                  gboolean    return_exposes,
2032                  GdkEvent  **event)
2033 {
2034   HRGN hrgn = CreateRectRgn (0, 0, 0, 0);
2035   HDC hdc;
2036   PAINTSTRUCT paintstruct;
2037   GdkRegion *update_region;
2038   gint xoffset, yoffset;
2039
2040   if (GetUpdateRgn (msg->hwnd, hrgn, FALSE) == ERROR)
2041     {
2042       WIN32_GDI_FAILED ("GetUpdateRgn");
2043       return;
2044     }
2045
2046   hdc = BeginPaint (msg->hwnd, &paintstruct);
2047
2048   GDK_NOTE (EVENTS, g_print (" %s %s dc %p%s",
2049                              _gdk_win32_rect_to_string (&paintstruct.rcPaint),
2050                              (paintstruct.fErase ? "erase" : ""),
2051                              hdc,
2052                              (return_exposes ? " return_exposes" : "")));
2053
2054   EndPaint (msg->hwnd, &paintstruct);
2055
2056   /* HB: don't generate GDK_EXPOSE events for InputOnly
2057    * windows -> backing store now works!
2058    */
2059   if (((GdkWindowObject *) window)->input_only)
2060     {
2061       DeleteObject (hrgn);
2062       return;
2063     }
2064
2065   if (!(((GdkWindowObject *) window)->event_mask & GDK_EXPOSURE_MASK))
2066     {
2067       GDK_NOTE (EVENTS, g_print (" (ignored)"));
2068       DeleteObject (hrgn);
2069       return;
2070     }
2071
2072 #if 0 /* we need to process exposes even with GDK_NO_BG
2073    * Otherwise The GIMP canvas update is broken ....
2074    */
2075   if (((GdkWindowObject *) window)->bg_pixmap == GDK_NO_BG)
2076     break;
2077 #endif
2078
2079   if ((paintstruct.rcPaint.right == paintstruct.rcPaint.left) ||
2080       (paintstruct.rcPaint.bottom == paintstruct.rcPaint.top))
2081     {
2082       GDK_NOTE (EVENTS, g_print (" (empty paintstruct, ignored)"));
2083       DeleteObject (hrgn);
2084       return;
2085     }
2086
2087   if (return_exposes)
2088     {
2089       if (!GDK_WINDOW_DESTROYED (window))
2090         {
2091           GList *list = gdk_drawable_get_display (window)->queued_events;
2092
2093           *event = gdk_event_new (GDK_EXPOSE);
2094           (*event)->expose.window = window;
2095           (*event)->expose.area.x = paintstruct.rcPaint.left;
2096           (*event)->expose.area.y = paintstruct.rcPaint.top;
2097           (*event)->expose.area.width = paintstruct.rcPaint.right - paintstruct.rcPaint.left;
2098           (*event)->expose.area.height = paintstruct.rcPaint.bottom - paintstruct.rcPaint.top;
2099           (*event)->expose.region = _gdk_win32_hrgn_to_region (hrgn);
2100           (*event)->expose.count = 0;
2101
2102           while (list != NULL)
2103             {
2104               GdkEventPrivate *evp = list->data;
2105
2106               if (evp->event.any.type == GDK_EXPOSE &&
2107                   evp->event.any.window == window &&
2108                   !(evp->flags & GDK_EVENT_PENDING))
2109                 evp->event.expose.count++;
2110
2111               list = list->next;
2112             }
2113         }
2114
2115       return;
2116     }
2117
2118   update_region = _gdk_win32_hrgn_to_region (hrgn);
2119
2120   _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2121   gdk_region_offset (update_region, xoffset, yoffset);
2122
2123   _gdk_window_process_expose (window, update_region);
2124   gdk_region_destroy (update_region);
2125
2126   DeleteObject (hrgn);
2127 }
2128
2129 static void
2130 handle_stuff_while_moving_or_resizing (void)
2131 {
2132   int arbitrary_limit = 1;
2133   while (g_main_pending () && arbitrary_limit--)
2134     g_main_iteration (FALSE);
2135 }
2136
2137 static VOID CALLBACK
2138 resize_timer_proc (HWND     hwnd,
2139                    UINT     msg,
2140                    UINT     id,
2141                    DWORD    time)
2142 {
2143   if (_sizemove_in_progress)
2144     handle_stuff_while_moving_or_resizing ();
2145 }
2146
2147 static void
2148 handle_display_change (void)
2149 {
2150   _gdk_monitor_init ();
2151   _gdk_root_window_size_init ();
2152   g_signal_emit_by_name (_gdk_screen, "size_changed");
2153 }
2154
2155 static gboolean
2156 gdk_event_translate (GdkDisplay *display,
2157                      MSG        *msg,
2158                      gint       *ret_valp)
2159 {
2160   RECT rect, *drag, orig_drag;
2161   POINT point;
2162   MINMAXINFO *mmi;
2163   HWND hwnd;
2164   HCURSOR hcursor;
2165   BYTE key_state[256];
2166   HIMC himc;
2167
2168   GdkEvent *event;
2169
2170   wchar_t wbuf[100];
2171   gint ccount;
2172
2173   GdkWindow *window = NULL;
2174   GdkWindowImplWin32 *impl;
2175
2176   GdkWindow *orig_window, *new_window;
2177   gint xoffset, yoffset;
2178
2179   static gint update_colors_counter = 0;
2180   gint button;
2181
2182   gchar buf[256];
2183   gboolean return_val = FALSE;
2184
2185   int i;
2186
2187   if (_gdk_default_filters)
2188     {
2189       /* Apply global filters */
2190
2191       GdkFilterReturn result =
2192         apply_filters (display, NULL, msg, _gdk_default_filters);
2193
2194       /* If result is GDK_FILTER_CONTINUE, we continue as if nothing
2195        * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
2196        * we return TRUE, and DefWindowProc() will not be called.
2197        */
2198       if (result == GDK_FILTER_REMOVE ||
2199           result == GDK_FILTER_TRANSLATE)
2200         return TRUE;
2201     }
2202
2203   window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd);
2204   orig_window = window;
2205
2206   if (window == NULL)
2207     {
2208       /* XXX Handle WM_QUIT here ? */
2209       if (msg->message == WM_QUIT)
2210         {
2211           GDK_NOTE (EVENTS, g_print (" %d", msg->wParam));
2212           exit (msg->wParam);
2213         }
2214       else if (msg->message == WM_MOVE ||
2215                msg->message == WM_SIZE)
2216         {
2217           /* It's quite normal to get these messages before we have
2218            * had time to register the window in our lookup table, or
2219            * when the window is being destroyed and we already have
2220            * removed it. Repost the same message to our queue so that
2221            * we will get it later when we are prepared.
2222            */
2223           GDK_NOTE (EVENTS, g_print (" (posted)"));
2224
2225           PostMessage (msg->hwnd, msg->message,
2226                        msg->wParam, msg->lParam);
2227         }
2228       else if (msg->message == WM_CREATE)
2229         {
2230           window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
2231           GDK_WINDOW_HWND (window) = msg->hwnd;
2232         }
2233       else
2234         {
2235           GDK_NOTE (EVENTS, g_print (" (no GdkWindow)"));
2236         }
2237       return FALSE;
2238     }
2239
2240   g_object_ref (window);
2241
2242   /* window's refcount has now been increased, so code below should
2243    * not just return from this function, but instead goto done (or
2244    * break out of the big switch). To protect against forgetting this,
2245    * #define return to a syntax error...
2246    */
2247 #define return GOTO_DONE_INSTEAD
2248
2249   if (!GDK_WINDOW_DESTROYED (window) && ((GdkWindowObject *) window)->filters)
2250     {
2251       /* Apply per-window filters */
2252
2253       GdkFilterReturn result =
2254         apply_filters (display, window, msg, ((GdkWindowObject *) window)->filters);
2255
2256       if (result == GDK_FILTER_REMOVE ||
2257           result == GDK_FILTER_TRANSLATE)
2258         {
2259           return_val = TRUE;
2260           goto done;
2261         }
2262     }
2263
2264   if (msg->message == msh_mousewheel)
2265     {
2266       GDK_NOTE (EVENTS, g_print (" (MSH_MOUSEWHEEL)"));
2267
2268       /* MSG_MOUSEWHEEL is delivered to the foreground window.  Work
2269        * around that. Also, the position is in screen coordinates, not
2270        * client coordinates as with the button messages.
2271        */
2272       point.x = GET_X_LPARAM (msg->lParam);
2273       point.y = GET_Y_LPARAM (msg->lParam);
2274       if ((hwnd = WindowFromPoint (point)) == NULL)
2275         goto done;
2276
2277       msg->hwnd = hwnd;
2278       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2279         goto done;
2280
2281       assign_object (&window, new_window);
2282
2283       if (!propagate (&window, msg,
2284                       p_grab_window, p_grab_owner_events, p_grab_mask,
2285                       doesnt_want_scroll, TRUE))
2286         goto done;
2287
2288       if (GDK_WINDOW_DESTROYED (window))
2289         goto done;
2290
2291       ScreenToClient (msg->hwnd, &point);
2292
2293       event = gdk_event_new (GDK_SCROLL);
2294       event->scroll.window = window;
2295       event->scroll.direction = ((int) msg->wParam > 0) ?
2296         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2297       event->scroll.time = _gdk_win32_get_next_tick (msg->time);
2298       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2299       event->scroll.x = (gint16) point.x + xoffset;
2300       event->scroll.y = (gint16) point.y + yoffset;
2301       event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;
2302       event->scroll.y_root = (gint16) GET_Y_LPARAM (msg->lParam) + _gdk_offset_y;
2303       event->scroll.state = 0;  /* No state information with MSH_MOUSEWHEEL */
2304       event->scroll.device = display->core_pointer;
2305
2306       append_event (display, event);
2307
2308       return_val = TRUE;
2309       goto done;
2310     }
2311   else if (msg->message == client_message)
2312     {
2313       GList *tmp_list;
2314       GdkFilterReturn result = GDK_FILTER_CONTINUE;
2315
2316       GDK_NOTE (EVENTS, g_print (" client_message"));
2317
2318       tmp_list = client_filters;
2319       while (tmp_list)
2320         {
2321           GdkClientFilter *filter = tmp_list->data;
2322
2323           tmp_list = tmp_list->next;
2324
2325           if (filter->type == GDK_POINTER_TO_ATOM (msg->wParam))
2326             {
2327               GList *filter_list = g_list_append (NULL, filter);
2328
2329               GDK_NOTE (EVENTS, g_print (" (match)"));
2330
2331               result = apply_filters (display, window, msg, filter_list);
2332
2333               g_list_free (filter_list);
2334
2335               if (result != GDK_FILTER_CONTINUE)
2336                 break;
2337             }
2338         }
2339
2340       if (result == GDK_FILTER_REMOVE ||
2341           result == GDK_FILTER_TRANSLATE)
2342         {
2343           return_val = TRUE;
2344           goto done;
2345         }
2346       else
2347         {
2348           /* Send unknown client messages on to Gtk for it to use */
2349
2350           event = gdk_event_new (GDK_CLIENT_EVENT);
2351           event->client.window = window;
2352           event->client.message_type = GDK_POINTER_TO_ATOM (msg->wParam);
2353           event->client.data_format = 32;
2354           event->client.data.l[0] = msg->lParam;
2355           for (i = 1; i < 5; i++)
2356             event->client.data.l[i] = 0;
2357
2358           append_event (display, event);
2359
2360           return_val = TRUE;
2361           goto done;
2362         }
2363     }
2364
2365   switch (msg->message)
2366     {
2367     case WM_INPUTLANGCHANGE:
2368       _gdk_input_locale = (HKL) msg->lParam;
2369       _gdk_input_locale_is_ime = ImmIsIME (_gdk_input_locale);
2370       GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
2371                      LOCALE_IDEFAULTANSICODEPAGE,
2372                      buf, sizeof (buf));
2373       _gdk_input_codepage = atoi (buf);
2374       _gdk_keymap_serial++;
2375       GDK_NOTE (EVENTS,
2376                 g_print (" cs:%lu hkl:%lx%s cp:%d",
2377                          (gulong) msg->wParam,
2378                          msg->lParam, _gdk_input_locale_is_ime ? " (IME)" : "",
2379                          _gdk_input_codepage));
2380       break;
2381
2382     case WM_SYSKEYUP:
2383     case WM_SYSKEYDOWN:
2384       GDK_NOTE (EVENTS,
2385                 g_print (" %s ch:%.02x %s",
2386                          _gdk_win32_key_to_string (msg->lParam),
2387                          msg->wParam,
2388                          decode_key_lparam (msg->lParam)));
2389
2390       /* If posted without us having keyboard focus, ignore */
2391       if ((msg->wParam != VK_F10 && msg->wParam != VK_MENU) &&
2392           !(HIWORD (msg->lParam) & KF_ALTDOWN))
2393         break;
2394
2395       /* Let the system handle Alt-Tab, Alt-Space, Alt-Enter and
2396        * Alt-F4 unless the keyboard is grabbed.
2397        */
2398       if (k_grab_window == NULL &&
2399           (msg->wParam == VK_TAB ||
2400            msg->wParam == VK_SPACE ||
2401            msg->wParam == VK_RETURN ||
2402            msg->wParam == VK_F4))
2403         break;
2404
2405       /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
2406       goto keyup_or_down;
2407
2408     case WM_KEYUP:
2409     case WM_KEYDOWN:
2410       GDK_NOTE (EVENTS,
2411                 g_print (" %s ch:%.02x %s",
2412                          _gdk_win32_key_to_string (msg->lParam),
2413                          msg->wParam,
2414                          decode_key_lparam (msg->lParam)));
2415
2416     keyup_or_down:
2417
2418       /* Ignore key messages intended for the IME */
2419       if (msg->wParam == VK_PROCESSKEY ||
2420           in_ime_composition)
2421         break;
2422
2423       if (!propagate (&window, msg,
2424                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2425                       doesnt_want_key, FALSE))
2426         break;
2427
2428       if (GDK_WINDOW_DESTROYED (window))
2429         break;
2430
2431       event = gdk_event_new ((msg->message == WM_KEYDOWN ||
2432                               msg->message == WM_SYSKEYDOWN) ?
2433                              GDK_KEY_PRESS : GDK_KEY_RELEASE);
2434       event->key.window = window;
2435       event->key.time = _gdk_win32_get_next_tick (msg->time);
2436       event->key.keyval = GDK_VoidSymbol;
2437       event->key.string = NULL;
2438       event->key.length = 0;
2439       event->key.hardware_keycode = msg->wParam;
2440
2441       API_CALL (GetKeyboardState, (key_state));
2442
2443       /* g_print ("ctrl:%02x lctrl:%02x rctrl:%02x alt:%02x lalt:%02x ralt:%02x\n", key_state[VK_CONTROL], key_state[VK_LCONTROL], key_state[VK_RCONTROL], key_state[VK_MENU], key_state[VK_LMENU], key_state[VK_RMENU]); */
2444
2445       build_key_event_state (event, key_state);
2446
2447       gdk_keymap_translate_keyboard_state (NULL,
2448                                            event->key.hardware_keycode,
2449                                            event->key.state,
2450                                            event->key.group,
2451                                            &event->key.keyval,
2452                                            NULL, NULL, NULL);
2453
2454       fill_key_event_string (event);
2455
2456       /* Reset MOD1_MASK if it is the Alt key itself */
2457       if (msg->wParam == VK_MENU)
2458         event->key.state &= ~GDK_MOD1_MASK;
2459
2460       append_event (display, event);
2461
2462       return_val = TRUE;
2463       break;
2464
2465     case WM_SYSCHAR:
2466       if (msg->wParam != VK_SPACE)
2467         {
2468           /* To prevent beeps, don't let DefWindowProc() be called */
2469           return_val = TRUE;
2470           goto done;
2471         }
2472       break;
2473
2474     case WM_IME_STARTCOMPOSITION:
2475       in_ime_composition = TRUE;
2476       break;
2477
2478     case WM_IME_ENDCOMPOSITION:
2479       in_ime_composition = FALSE;
2480       break;
2481
2482     case WM_IME_COMPOSITION:
2483       /* On Win2k WM_IME_CHAR doesn't work correctly for non-Unicode
2484        * applications. Thus, handle WM_IME_COMPOSITION with
2485        * GCS_RESULTSTR instead, fetch the Unicode chars from the IME
2486        * with ImmGetCompositionStringW().
2487        *
2488        * See for instance
2489        * http://groups.google.com/groups?selm=natX5.57%24g77.19788%40nntp2.onemain.com
2490        * and
2491        * http://groups.google.com/groups?selm=u2XfrXw5BHA.1628%40tkmsftngp02
2492        * for comments by other people that seems to have the same
2493        * experience. WM_IME_CHAR just gives question marks, apparently
2494        * because of going through some conversion to the current code
2495        * page.
2496        *
2497        * WM_IME_CHAR might work on NT4 or Win9x with ActiveIMM, but
2498        * use WM_IME_COMPOSITION there, too, to simplify the code.
2499        */
2500       GDK_NOTE (EVENTS, g_print (" %#lx", msg->lParam));
2501
2502       if (!(msg->lParam & GCS_RESULTSTR))
2503         break;
2504
2505       if (!propagate (&window, msg,
2506                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2507                       doesnt_want_char, FALSE))
2508         break;
2509
2510       if (GDK_WINDOW_DESTROYED (window))
2511         break;
2512
2513       himc = ImmGetContext (msg->hwnd);
2514       ccount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
2515                                          wbuf, sizeof (wbuf));
2516       ImmReleaseContext (msg->hwnd, himc);
2517
2518       ccount /= 2;
2519
2520       API_CALL (GetKeyboardState, (key_state));
2521
2522       for (i = 0; i < ccount; i++)
2523         {
2524           if (((GdkWindowObject *) window)->event_mask & GDK_KEY_PRESS_MASK)
2525             {
2526               /* Build a key press event */
2527               event = gdk_event_new (GDK_KEY_PRESS);
2528               event->key.window = window;
2529               build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
2530
2531               append_event (display, event);
2532             }
2533
2534           if (((GdkWindowObject *) window)->event_mask & GDK_KEY_RELEASE_MASK)
2535             {
2536               /* Build a key release event.  */
2537               event = gdk_event_new (GDK_KEY_RELEASE);
2538               event->key.window = window;
2539               build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
2540
2541               append_event (display, event);
2542             }
2543         }
2544       return_val = TRUE;
2545       break;
2546
2547     case WM_LBUTTONDOWN:
2548       button = 1;
2549       goto buttondown0;
2550
2551     case WM_MBUTTONDOWN:
2552       button = 2;
2553       goto buttondown0;
2554
2555     case WM_RBUTTONDOWN:
2556       button = 3;
2557       goto buttondown0;
2558
2559     case WM_XBUTTONDOWN:
2560       if (HIWORD (msg->wParam) == XBUTTON1)
2561         button = 4;
2562       else
2563         button = 5;
2564
2565     buttondown0:
2566       GDK_NOTE (EVENTS,
2567                 g_print (" (%d,%d)",
2568                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2569
2570       assign_object (&window, find_window_for_mouse_event (window, msg));
2571
2572       if (p_grab_window != NULL)
2573         {
2574           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2575
2576           if (real_window != current_window)
2577             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2578         }
2579       else
2580         {
2581           if (window != current_window)
2582             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2583         }
2584
2585       if (!propagate (&window, msg,
2586                       p_grab_window, p_grab_owner_events, p_grab_mask,
2587                       doesnt_want_button_press, TRUE))
2588         break;
2589
2590       if (GDK_WINDOW_DESTROYED (window))
2591         break;
2592
2593       /* Emulate X11's automatic active grab */
2594       if (!p_grab_window)
2595         {
2596           /* No explicit active grab, let's start one automatically */
2597           GDK_NOTE (EVENTS, g_print (" (automatic grab)"));
2598           gdk_pointer_grab (window,
2599                             FALSE,
2600                             ((GdkWindowObject *) window)->event_mask,
2601                             NULL, NULL, 0);
2602           p_grab_automatic = TRUE;
2603         }
2604
2605       event = gdk_event_new (GDK_BUTTON_PRESS);
2606       event->button.window = window;
2607       event->button.time = _gdk_win32_get_next_tick (msg->time);
2608       if (window != orig_window)
2609         translate_mouse_coords (orig_window, window, msg);
2610       event->button.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2611       event->button.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2612       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2613       event->button.x += xoffset;
2614       event->button.y += yoffset;
2615       event->button.x_root = msg->pt.x + _gdk_offset_x;
2616       event->button.y_root = msg->pt.y + _gdk_offset_y;
2617       event->button.axes = NULL;
2618       event->button.state = build_pointer_event_state (msg);
2619       event->button.button = button;
2620       event->button.device = display->core_pointer;
2621
2622       append_event (display, event);
2623
2624       _gdk_event_button_generate (display, event);
2625
2626       return_val = TRUE;
2627       break;
2628
2629     case WM_LBUTTONUP:
2630       button = 1;
2631       goto buttonup0;
2632
2633     case WM_MBUTTONUP:
2634       button = 2;
2635       goto buttonup0;
2636
2637     case WM_RBUTTONUP:
2638       button = 3;
2639       goto buttonup0;
2640
2641     case WM_XBUTTONUP:
2642       if (HIWORD (msg->wParam) == XBUTTON1)
2643         button = 4;
2644       else
2645         button = 5;
2646
2647     buttonup0:
2648       GDK_NOTE (EVENTS,
2649                 g_print (" (%d,%d)",
2650                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2651
2652       assign_object (&window, find_window_for_mouse_event (window, msg));
2653
2654       if (p_grab_window != NULL)
2655         {
2656           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2657
2658           if (real_window != current_window)
2659             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2660         }
2661       else
2662         {
2663           if (window != current_window)
2664             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2665         }
2666
2667 #if 0
2668       if (((GdkWindowObject *) window)->extension_events != 0 &&
2669           _gdk_input_ignore_core)
2670         {
2671           GDK_NOTE (EVENTS, g_print (" (ignored)"));
2672           break;
2673         }
2674 #endif
2675
2676       if (!propagate (&window, msg,
2677                       p_grab_window, p_grab_owner_events, p_grab_mask,
2678                       doesnt_want_button_release, TRUE))
2679         {
2680         }
2681       else if (!GDK_WINDOW_DESTROYED (window))
2682         {
2683           event = gdk_event_new (GDK_BUTTON_RELEASE);
2684           event->button.window = window;
2685           event->button.time = _gdk_win32_get_next_tick (msg->time);
2686           if (window != orig_window)
2687             translate_mouse_coords (orig_window, window, msg);
2688           event->button.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2689           event->button.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2690           _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2691           event->button.x += xoffset;
2692           event->button.y += yoffset;
2693           event->button.x_root = msg->pt.x + _gdk_offset_x;
2694           event->button.y_root = msg->pt.y + _gdk_offset_y;
2695           event->button.axes = NULL;
2696           event->button.state = build_pointer_event_state (msg);
2697           event->button.button = button;
2698           event->button.device = display->core_pointer;
2699
2700           append_event (display, event);
2701         }
2702
2703       if (p_grab_window != NULL &&
2704           p_grab_automatic &&
2705           (msg->wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) == 0)
2706         {
2707           /* Terminate automatic grab */
2708           gdk_pointer_ungrab (0);
2709         }
2710
2711       return_val = TRUE;
2712       break;
2713
2714     case WM_MOUSEMOVE:
2715       GDK_NOTE (EVENTS,
2716                 g_print (" %#x (%d,%d)",
2717                          msg->wParam,
2718                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2719
2720       assign_object (&window, find_window_for_mouse_event (window, msg));
2721
2722       if (p_grab_window != NULL)
2723         {
2724           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2725
2726           if (real_window != current_window)
2727             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2728         }
2729       else
2730         {
2731           if (window != current_window)
2732             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2733         }
2734
2735       if (!propagate (&window, msg,
2736                       p_grab_window, p_grab_owner_events, p_grab_mask,
2737                       doesnt_want_button_motion, TRUE))
2738         break;
2739
2740       if (GDK_WINDOW_DESTROYED (window))
2741         break;
2742
2743       if (window != orig_window)
2744         translate_mouse_coords (orig_window, window, msg);
2745
2746       /* If we haven't moved, don't create any event.
2747        * Windows sends WM_MOUSEMOVE messages after button presses
2748        * even if the mouse doesn't move. This disturbs gtk.
2749        */
2750       if (window == current_window &&
2751           GET_X_LPARAM (msg->lParam) == current_x &&
2752           GET_Y_LPARAM (msg->lParam) == current_y)
2753         break;
2754
2755       event = gdk_event_new (GDK_MOTION_NOTIFY);
2756       event->motion.window = window;
2757       event->motion.time = _gdk_win32_get_next_tick (msg->time);
2758       event->motion.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2759       event->motion.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2760       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2761       event->motion.x += xoffset;
2762       event->motion.y += yoffset;
2763       event->motion.x_root = msg->pt.x + _gdk_offset_x;
2764       event->motion.y_root = msg->pt.y + _gdk_offset_y;
2765       event->motion.axes = NULL;
2766       event->motion.state = build_pointer_event_state (msg);
2767       event->motion.is_hint = FALSE;
2768       event->motion.device = display->core_pointer;
2769
2770       append_event (display, event);
2771
2772       return_val = TRUE;
2773       break;
2774
2775     case WM_NCMOUSEMOVE:
2776       GDK_NOTE (EVENTS,
2777                 g_print (" (%d,%d)",
2778                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2779       if (current_window != NULL &&
2780           (((GdkWindowObject *) current_window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2781         {
2782           synthesize_crossing_events (_gdk_root, GDK_CROSSING_NORMAL, msg);
2783         }
2784
2785       break;
2786
2787     case WM_MOUSELEAVE:
2788       GDK_NOTE (EVENTS, g_print (" %d (%ld,%ld)",
2789                                  HIWORD (msg->wParam), msg->pt.x, msg->pt.y));
2790
2791       if (!gdk_win32_handle_table_lookup ((GdkNativeWindow) WindowFromPoint (msg->pt)))
2792         {
2793           GdkNotifyType detail;
2794
2795           if (GDK_WINDOW_TYPE (current_window) != GDK_WINDOW_CHILD)
2796             detail = GDK_NOTIFY_ANCESTOR;
2797           else
2798             detail = GDK_NOTIFY_UNKNOWN;
2799
2800           /* we are only interested if we don't know the new window */
2801           synthesize_enter_or_leave_event (current_window, msg,
2802                                            GDK_LEAVE_NOTIFY, GDK_CROSSING_NORMAL, detail,
2803                                            current_x, current_y);
2804         }
2805       else
2806         {
2807           GDK_NOTE (EVENTS, g_print (" (ignored)"));
2808         }
2809       return_val = TRUE;
2810       break;
2811
2812     case WM_MOUSEWHEEL:
2813       GDK_NOTE (EVENTS, g_print (" %d", HIWORD (msg->wParam)));
2814
2815       /* WM_MOUSEWHEEL is delivered to the focus window. Work around
2816        * that. Also, the position is in screen coordinates, not client
2817        * coordinates as with the button messages. I love the
2818        * consistency of Windows.
2819        */
2820       point.x = GET_X_LPARAM (msg->lParam);
2821       point.y = GET_Y_LPARAM (msg->lParam);
2822
2823       if ((hwnd = WindowFromPoint (point)) == NULL)
2824         break;
2825
2826       msg->hwnd = hwnd;
2827       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2828         break;
2829
2830       if (new_window != window)
2831         {
2832           assign_object (&window, new_window);
2833         }
2834
2835       if (!propagate (&window, msg,
2836                       p_grab_window, p_grab_owner_events, p_grab_mask,
2837                       doesnt_want_scroll, TRUE))
2838         break;
2839
2840       if (GDK_WINDOW_DESTROYED (window))
2841         break;
2842
2843       ScreenToClient (msg->hwnd, &point);
2844
2845       event = gdk_event_new (GDK_SCROLL);
2846       event->scroll.window = window;
2847       event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2848         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2849       event->scroll.window = window;
2850       event->scroll.time = _gdk_win32_get_next_tick (msg->time);
2851       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2852       event->scroll.x = (gint16) point.x + xoffset;
2853       event->scroll.y = (gint16) point.y + yoffset;
2854       event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;
2855       event->scroll.y_root = (gint16) GET_Y_LPARAM (msg->lParam) + _gdk_offset_y;
2856       event->scroll.state = build_pointer_event_state (msg);
2857       event->scroll.device = display->core_pointer;
2858
2859       append_event (display, event);
2860
2861       return_val = TRUE;
2862       break;
2863
2864     case WM_QUERYNEWPALETTE:
2865       if (gdk_visual_get_system ()->type == GDK_VISUAL_PSEUDO_COLOR)
2866         {
2867           synthesize_expose_events (window);
2868           update_colors_counter = 0;
2869         }
2870       return_val = TRUE;
2871       break;
2872
2873     case WM_PALETTECHANGED:
2874       GDK_NOTE (EVENTS_OR_COLORMAP, g_print (" %p", (HWND) msg->wParam));
2875       if (gdk_visual_get_system ()->type != GDK_VISUAL_PSEUDO_COLOR)
2876         break;
2877
2878       return_val = TRUE;
2879
2880       if (msg->hwnd == (HWND) msg->wParam)
2881         break;
2882
2883       if (++update_colors_counter == 5)
2884         {
2885           synthesize_expose_events (window);
2886           update_colors_counter = 0;
2887           break;
2888         }
2889
2890       update_colors (window, TRUE);
2891       break;
2892
2893      case WM_MOUSEACTIVATE:
2894        if (gdk_window_get_window_type (window) == GDK_WINDOW_TEMP)
2895          {
2896            *ret_valp = MA_NOACTIVATE;
2897            return_val = TRUE;
2898          }
2899        break;
2900
2901     case WM_SETFOCUS:
2902     case WM_KILLFOCUS:
2903       if (k_grab_window != NULL && !k_grab_owner_events)
2904         break;
2905
2906       if (!(((GdkWindowObject *) window)->event_mask & GDK_FOCUS_CHANGE_MASK))
2907         break;
2908
2909       if (GDK_WINDOW_DESTROYED (window))
2910         break;
2911
2912       generate_focus_event (window, (msg->message == WM_SETFOCUS));
2913       return_val = TRUE;
2914       break;
2915
2916     case WM_ERASEBKGND:
2917       GDK_NOTE (EVENTS, g_print (" %p", (HANDLE) msg->wParam));
2918
2919       if (GDK_WINDOW_DESTROYED (window))
2920         break;
2921
2922       erase_background (window, (HDC) msg->wParam);
2923       return_val = TRUE;
2924       *ret_valp = 1;
2925       break;
2926
2927     case WM_PAINT:
2928       handle_wm_paint (msg, window, FALSE, NULL);
2929       break;
2930
2931     case WM_SETCURSOR:
2932       GDK_NOTE (EVENTS, g_print (" %#x %#x",
2933                                  LOWORD (msg->lParam), HIWORD (msg->lParam)));
2934
2935       if (p_grab_window == NULL && LOWORD (msg->lParam) != HTCLIENT)
2936         break;
2937
2938       if (p_grab_window != NULL && p_grab_cursor != NULL)
2939         hcursor = p_grab_cursor;
2940       else if (!GDK_WINDOW_DESTROYED (window))
2941         hcursor = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->hcursor;
2942       else
2943         hcursor = NULL;
2944
2945       if (hcursor != NULL)
2946         {
2947           GDK_NOTE (EVENTS, g_print (" (SetCursor(%p)", hcursor));
2948           SetCursor (hcursor);
2949           return_val = TRUE;
2950           *ret_valp = TRUE;
2951         }
2952       break;
2953
2954     case WM_SHOWWINDOW:
2955       GDK_NOTE (EVENTS, g_print (" %d", msg->wParam));
2956
2957       if (!(((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK))
2958         break;
2959
2960       if (msg->lParam == SW_OTHERUNZOOM ||
2961           msg->lParam == SW_OTHERZOOM)
2962         break;
2963
2964       if (GDK_WINDOW_DESTROYED (window))
2965         break;
2966
2967       event = gdk_event_new (msg->wParam ? GDK_MAP : GDK_UNMAP);
2968       event->any.window = window;
2969
2970       append_event (display, event);
2971
2972       if (event->any.type == GDK_UNMAP &&
2973           p_grab_window == window)
2974         gdk_pointer_ungrab (msg->time);
2975
2976       if (event->any.type == GDK_UNMAP &&
2977           k_grab_window == window)
2978         gdk_keyboard_ungrab (msg->time);
2979
2980       return_val = TRUE;
2981       break;
2982
2983     case WM_SIZE:
2984       GDK_NOTE (EVENTS,
2985                 g_print (" %s %dx%d",
2986                          (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
2987                           (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
2988                            (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
2989                             (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
2990                              (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
2991                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
2992
2993       if (msg->wParam == SIZE_MINIMIZED)
2994         {
2995           /* Don't generate any GDK event. This is *not* an UNMAP. */
2996
2997           if (p_grab_window == window)
2998             gdk_pointer_ungrab (msg->time);
2999
3000           if (k_grab_window == window)
3001             gdk_keyboard_ungrab (msg->time);
3002
3003           gdk_synthesize_window_state (window,
3004                                        GDK_WINDOW_STATE_WITHDRAWN,
3005                                        GDK_WINDOW_STATE_ICONIFIED);
3006         }
3007       else if ((msg->wParam == SIZE_RESTORED ||
3008                 msg->wParam == SIZE_MAXIMIZED) &&
3009                GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD)
3010         {
3011           GdkWindowState withdrawn_bit =
3012             IsWindowVisible (msg->hwnd) ? GDK_WINDOW_STATE_WITHDRAWN : 0;
3013
3014           if (!GDK_WINDOW_DESTROYED (window))
3015             handle_configure_event (msg, window);
3016
3017           if (msg->wParam == SIZE_RESTORED)
3018             gdk_synthesize_window_state (window,
3019                                          GDK_WINDOW_STATE_ICONIFIED |
3020                                          GDK_WINDOW_STATE_MAXIMIZED |
3021                                          withdrawn_bit,
3022                                          0);
3023           else if (msg->wParam == SIZE_MAXIMIZED)
3024             gdk_synthesize_window_state (window,
3025                                          GDK_WINDOW_STATE_ICONIFIED |
3026                                          withdrawn_bit,
3027                                          GDK_WINDOW_STATE_MAXIMIZED);
3028
3029           if (((GdkWindowObject *) window)->resize_count > 1)
3030             ((GdkWindowObject *) window)->resize_count -= 1;
3031
3032           if (((GdkWindowObject *) window)->extension_events != 0)
3033             _gdk_input_configure_event (window);
3034
3035           return_val = TRUE;
3036         }
3037       break;
3038
3039     case WM_ENTERSIZEMOVE:
3040       _sizemove_in_progress = TRUE;
3041       resize_timer = SetTimer (NULL, 0, 20, resize_timer_proc);
3042       break;
3043
3044     case WM_EXITSIZEMOVE:
3045       _sizemove_in_progress = FALSE;
3046       KillTimer (NULL, resize_timer);
3047       break;
3048
3049     case WM_WINDOWPOSCHANGED :
3050       /* Once we've entered the moving or sizing modal loop, we won't
3051        * return to the main loop until we're done sizing or moving.
3052        */
3053       if (_sizemove_in_progress &&
3054          GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&
3055          !GDK_WINDOW_DESTROYED (window))
3056         {
3057           RECT client_rect;
3058           POINT point;
3059
3060           GetClientRect (msg->hwnd, &client_rect);
3061           point.x = client_rect.left; /* always 0 */
3062           point.y = client_rect.top;
3063           /* top level windows need screen coords */
3064           if (gdk_window_get_parent (window) == _gdk_root)
3065             {
3066               ClientToScreen (msg->hwnd, &point);
3067               point.x += _gdk_offset_x;
3068               point.y += _gdk_offset_y;
3069             }
3070
3071           GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->width = client_rect.right - client_rect.left;
3072           GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->height = client_rect.bottom - client_rect.top;
3073
3074           ((GdkWindowObject *) window)->x = point.x;
3075           ((GdkWindowObject *) window)->y = point.y;
3076
3077           if (((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK)
3078             {
3079               GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
3080
3081               event->configure.window = window;
3082
3083               event->configure.width = client_rect.right - client_rect.left;
3084               event->configure.height = client_rect.bottom - client_rect.top;
3085
3086               event->configure.x = point.x;
3087               event->configure.y = point.y;
3088
3089               if (((GdkWindowObject *) window)->resize_count > 1)
3090                 ((GdkWindowObject *) window)->resize_count -= 1;
3091
3092 #if 0 /* I don't like calling _gdk_event_func() from here, isn't there
3093        * a risk of getting events processed in the wrong order, like
3094        * Owen says in the discussion of bug #99540?
3095        */
3096               fixup_event (event);
3097               if (_gdk_event_func)
3098                 (*_gdk_event_func) (event, _gdk_event_data);
3099               gdk_event_free (event);
3100 #else /* Calling append_event() is slower, but guarantees that events won't
3101        * get reordered, I think.
3102        */
3103               append_event (display, event);
3104 #endif
3105
3106               /* Dispatch main loop - to realize resizes... */
3107               handle_stuff_while_moving_or_resizing ();
3108
3109               /* Claim as handled, so that WM_SIZE and WM_MOVE are avoided */
3110               return_val = TRUE;
3111               *ret_valp = 1;
3112             }
3113         }
3114       break;
3115
3116     case WM_SIZING:
3117       GetWindowRect (GDK_WINDOW_HWND (window), &rect);
3118       GDK_NOTE (EVENTS, g_print (" %s curr:%s drag:%s",
3119                                  (msg->wParam == WMSZ_BOTTOM ? "BOTTOM" :
3120                                   (msg->wParam == WMSZ_BOTTOMLEFT ? "BOTTOMLEFT" :
3121                                    (msg->wParam == WMSZ_LEFT ? "LEFT" :
3122                                     (msg->wParam == WMSZ_TOPLEFT ? "TOPLEFT" :
3123                                      (msg->wParam == WMSZ_TOP ? "TOP" :
3124                                       (msg->wParam == WMSZ_TOPRIGHT ? "TOPRIGHT" :
3125                                        (msg->wParam == WMSZ_RIGHT ? "RIGHT" :
3126
3127                                         (msg->wParam == WMSZ_BOTTOMRIGHT ? "BOTTOMRIGHT" :
3128                                          "???")))))))),
3129                                  _gdk_win32_rect_to_string (&rect),
3130                                  _gdk_win32_rect_to_string ((RECT *) msg->lParam)));
3131
3132       impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
3133       drag = (RECT *) msg->lParam;
3134       orig_drag = *drag;
3135       if (impl->hint_flags & GDK_HINT_RESIZE_INC)
3136         {
3137           if (impl->hint_flags & GDK_HINT_BASE_SIZE)
3138             {
3139               /* Resize in increments relative to the base size */
3140               rect.left = rect.top = 0;
3141               rect.right = impl->hints.base_width;
3142               rect.bottom = impl->hints.base_height;
3143               _gdk_win32_adjust_client_rect (window, &rect);
3144               point.x = rect.left;
3145               point.y = rect.top;
3146               ClientToScreen (GDK_WINDOW_HWND (window), &point);
3147               rect.left = point.x;
3148               rect.top = point.y;
3149               point.x = rect.right;
3150               point.y = rect.bottom;
3151               ClientToScreen (GDK_WINDOW_HWND (window), &point);
3152               rect.right = point.x;
3153               rect.bottom = point.y;
3154
3155               GDK_NOTE (EVENTS, g_print (" (also BASE_SIZE, using %s)",
3156                                          _gdk_win32_rect_to_string (&rect)));
3157             }
3158
3159           switch (msg->wParam)
3160             {
3161             case WMSZ_BOTTOM:
3162               if (drag->bottom == rect.bottom)
3163                 break;
3164               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3165
3166               break;
3167
3168             case WMSZ_BOTTOMLEFT:
3169               if (drag->bottom == rect.bottom && drag->left == rect.left)
3170                 break;
3171               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3172               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3173               break;
3174
3175             case WMSZ_LEFT:
3176               if (drag->left == rect.left)
3177                 break;
3178               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3179               break;
3180
3181             case WMSZ_TOPLEFT:
3182               if (drag->top == rect.top && drag->left == rect.left)
3183                 break;
3184               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3185               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3186               break;
3187
3188             case WMSZ_TOP:
3189               if (drag->top == rect.top)
3190                 break;
3191               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3192               break;
3193
3194             case WMSZ_TOPRIGHT:
3195               if (drag->top == rect.top && drag->right == rect.right)
3196                 break;
3197               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3198               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3199               break;
3200
3201             case WMSZ_RIGHT:
3202               if (drag->right == rect.right)
3203                 break;
3204               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3205               break;
3206
3207             case WMSZ_BOTTOMRIGHT:
3208               if (drag->bottom == rect.bottom && drag->right == rect.right)
3209                 break;
3210               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3211               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3212               break;
3213             }
3214
3215           if (drag->bottom != orig_drag.bottom || drag->left != orig_drag.left ||
3216               drag->top != orig_drag.top || drag->right != orig_drag.right)
3217             {
3218               *ret_valp = TRUE;
3219               return_val = TRUE;
3220               GDK_NOTE (EVENTS, g_print (" (handled RESIZE_INC: drag:%s)",
3221                                          _gdk_win32_rect_to_string (drag)));
3222             }
3223         }
3224
3225       /* WM_GETMINMAXINFO handles min_size and max_size hints? */
3226
3227       if (impl->hint_flags & GDK_HINT_ASPECT)
3228         {
3229           gdouble drag_aspect = (gdouble) (drag->right - drag->left) / (drag->bottom - drag->top);
3230
3231           GDK_NOTE (EVENTS, g_print (" (aspect:%g)", drag_aspect));
3232           if (drag_aspect < impl->hints.min_aspect ||
3233               drag_aspect > impl->hints.max_aspect)
3234             {
3235               *drag = rect;
3236               *ret_valp = TRUE;
3237               return_val = TRUE;
3238               GDK_NOTE (EVENTS, g_print (" (handled ASPECT: drag:%s)",
3239                                          _gdk_win32_rect_to_string (drag)));
3240             }
3241         }
3242       break;
3243
3244     case WM_GETMINMAXINFO:
3245       if (GDK_WINDOW_DESTROYED (window))
3246         break;
3247
3248       impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
3249       mmi = (MINMAXINFO*) msg->lParam;
3250       GDK_NOTE (EVENTS, g_print (" (mintrack:%ldx%ld maxtrack:%ldx%ld "
3251                                  "maxpos:%+ld%+ld maxsize:%ldx%ld)",
3252                                  mmi->ptMinTrackSize.x, mmi->ptMinTrackSize.y,
3253                                  mmi->ptMaxTrackSize.x, mmi->ptMaxTrackSize.y,
3254                                  mmi->ptMaxPosition.x, mmi->ptMaxPosition.y,
3255                                  mmi->ptMaxSize.x, mmi->ptMaxSize.y));
3256
3257       if (impl->hint_flags & GDK_HINT_MIN_SIZE)
3258         {
3259           rect.left = rect.top = 0;
3260           rect.right = impl->hints.min_width;
3261           rect.bottom = impl->hints.min_height;
3262
3263           _gdk_win32_adjust_client_rect (window, &rect);
3264
3265           mmi->ptMinTrackSize.x = rect.right - rect.left;
3266           mmi->ptMinTrackSize.y = rect.bottom - rect.top;
3267         }
3268
3269       if (impl->hint_flags & GDK_HINT_MAX_SIZE)
3270         {
3271           int maxw, maxh;
3272
3273           rect.left = rect.top = 0;
3274           rect.right = impl->hints.max_width;
3275           rect.bottom = impl->hints.max_height;
3276
3277           _gdk_win32_adjust_client_rect (window, &rect);
3278
3279           /* at least on win9x we have the 16 bit trouble */
3280           maxw = rect.right - rect.left;
3281           maxh = rect.bottom - rect.top;
3282           mmi->ptMaxTrackSize.x = maxw > 0 && maxw < G_MAXSHORT ? maxw : G_MAXSHORT;
3283           mmi->ptMaxTrackSize.y = maxh > 0 && maxh < G_MAXSHORT ? maxh : G_MAXSHORT;
3284         }
3285
3286       if (impl->hint_flags & (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE))
3287         {
3288           /* Don't call DefWindowProc() */
3289           GDK_NOTE (EVENTS, g_print (" (handled, mintrack:%ldx%ld maxtrack:%ldx%ld "
3290                                      "maxpos:%+ld%+ld maxsize:%ldx%ld)",
3291                                      mmi->ptMinTrackSize.x, mmi->ptMinTrackSize.y,
3292                                      mmi->ptMaxTrackSize.x, mmi->ptMaxTrackSize.y,
3293                                      mmi->ptMaxPosition.x, mmi->ptMaxPosition.y,
3294                                      mmi->ptMaxSize.x, mmi->ptMaxSize.y));
3295           return_val = TRUE;
3296         }
3297       break;
3298
3299     case WM_MOVE:
3300       GDK_NOTE (EVENTS, g_print (" (%d,%d)",
3301                                  GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
3302
3303       if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&
3304           !IsIconic (msg->hwnd))
3305         {
3306           if (!GDK_WINDOW_DESTROYED (window))
3307             handle_configure_event (msg, window);
3308
3309           return_val = TRUE;
3310         }
3311       break;
3312
3313     case WM_CLOSE:
3314       if (GDK_WINDOW_DESTROYED (window))
3315         break;
3316
3317       event = gdk_event_new (GDK_DELETE);
3318       event->any.window = window;
3319
3320       append_event (display, event);
3321
3322       return_val = TRUE;
3323       break;
3324
3325     case WM_DESTROY:
3326       if (window == current_window)
3327         assign_object (&current_window, _gdk_root);
3328
3329       if (p_grab_window == window)
3330         gdk_pointer_ungrab (msg->time);
3331
3332       if (k_grab_window == window)
3333         gdk_keyboard_ungrab (msg->time);
3334
3335       if ((window != NULL) && (msg->hwnd != GetDesktopWindow ()))
3336         gdk_window_destroy_notify (window);
3337
3338       if (window == NULL || GDK_WINDOW_DESTROYED (window))
3339         break;
3340
3341       event = gdk_event_new (GDK_DESTROY);
3342       event->any.window = window;
3343
3344       append_event (display, event);
3345
3346       return_val = TRUE;
3347       break;
3348
3349     case WM_DISPLAYCHANGE:
3350       handle_display_change ();
3351       break;
3352
3353     case WM_DESTROYCLIPBOARD:
3354       if (!_ignore_destroy_clipboard)
3355         {
3356           event = gdk_event_new (GDK_SELECTION_CLEAR);
3357           event->selection.window = window;
3358           event->selection.selection = GDK_SELECTION_CLIPBOARD;
3359           event->selection.time = _gdk_win32_get_next_tick (msg->time);
3360           append_event (display, event);
3361         }
3362       else
3363         return_val = TRUE;
3364       break;
3365
3366 #ifdef HAVE_WINTAB
3367     case WM_ACTIVATE:
3368       /* Bring any tablet contexts to the top of the overlap order when
3369        * one of our windows is activated.
3370        * NOTE: It doesn't seem to work well if it is done in WM_ACTIVATEAPP
3371        * instead
3372        */
3373       if (LOWORD(msg->wParam) != WA_INACTIVE)
3374         _gdk_input_set_tablet_active ();
3375       break;
3376
3377       /* Handle WINTAB events here, as we know that gdkinput.c will
3378        * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
3379        * constants as case labels.
3380        */
3381     case WT_PACKET:
3382       GDK_NOTE (EVENTS, g_print (" %d %#lx",
3383                                  msg->wParam, msg->lParam));
3384       goto wintab;
3385
3386     case WT_CSRCHANGE:
3387       GDK_NOTE (EVENTS, g_print (" %d %#lx",
3388                                  msg->wParam, msg->lParam));
3389       goto wintab;
3390
3391     case WT_PROXIMITY:
3392       GDK_NOTE (EVENTS, g_print (" %#x %d %d",
3393                                  msg->wParam,
3394                                  LOWORD (msg->lParam),
3395                                  HIWORD (msg->lParam)));
3396       /* Fall through */
3397     wintab:
3398
3399       event = gdk_event_new (GDK_NOTHING);
3400       event->any.window = window;
3401       g_object_ref (window);
3402       if (_gdk_input_other_event (event, msg, window))
3403         append_event (display, event);
3404       else
3405         gdk_event_free (event);
3406       break;
3407 #endif
3408     }
3409
3410 done:
3411
3412   if (window)
3413     g_object_unref (window);
3414
3415 #undef return
3416   return return_val;
3417 }
3418
3419 void
3420 _gdk_events_queue (GdkDisplay *display)
3421 {
3422   MSG msg;
3423
3424   while (!_gdk_event_queue_find_first (display) &&
3425          PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3426     {
3427       TranslateMessage (&msg);
3428       DispatchMessage (&msg);
3429     }
3430 }
3431
3432 static gboolean
3433 gdk_event_prepare (GSource *source,
3434                    gint    *timeout)
3435 {
3436   MSG msg;
3437   gboolean retval;
3438   GdkDisplay *display = gdk_display_get_default ();
3439
3440   GDK_THREADS_ENTER ();
3441
3442   *timeout = -1;
3443
3444   retval = (_gdk_event_queue_find_first (display) != NULL ||
3445             PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
3446
3447   GDK_THREADS_LEAVE ();
3448
3449   return retval;
3450 }
3451
3452 static gboolean
3453 gdk_event_check (GSource *source)
3454 {
3455   MSG msg;
3456   gboolean retval;
3457   GdkDisplay *display = gdk_display_get_default ();
3458
3459   GDK_THREADS_ENTER ();
3460
3461   if (event_poll_fd.revents & G_IO_IN)
3462     retval = (_gdk_event_queue_find_first (display) != NULL ||
3463               PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
3464   else
3465     retval = FALSE;
3466
3467   GDK_THREADS_LEAVE ();
3468
3469   return retval;
3470 }
3471
3472 static gboolean
3473 gdk_event_dispatch (GSource     *source,
3474                     GSourceFunc  callback,
3475                     gpointer     user_data)
3476 {
3477   GdkEvent *event;
3478   GdkDisplay *display = gdk_display_get_default ();
3479
3480   GDK_THREADS_ENTER ();
3481
3482   _gdk_events_queue (display);
3483   event = _gdk_event_unqueue (display);
3484
3485   if (event)
3486     {
3487       if (_gdk_event_func)
3488         (*_gdk_event_func) (event, _gdk_event_data);
3489
3490       gdk_event_free (event);
3491     }
3492
3493   GDK_THREADS_LEAVE ();
3494
3495   return TRUE;
3496 }
3497
3498 static void
3499 check_for_too_much_data (GdkEvent *event)
3500 {
3501   if (event->client.data.l[1] ||
3502       event->client.data.l[2] ||
3503       event->client.data.l[3] ||
3504       event->client.data.l[4])
3505     g_warning ("Only four bytes of data are passed in client messages on Win32\n");
3506 }
3507
3508 gboolean
3509 gdk_event_send_client_message_for_display (GdkDisplay     *display,
3510                                            GdkEvent       *event,
3511                                            GdkNativeWindow winid)
3512 {
3513   check_for_too_much_data (event);
3514
3515   return PostMessage ((HWND) winid, client_message,
3516                       (WPARAM) event->client.message_type,
3517                       event->client.data.l[0]);
3518 }
3519
3520 void
3521 gdk_screen_broadcast_client_message (GdkScreen *screen,
3522                                      GdkEvent  *event)
3523 {
3524   check_for_too_much_data (event);
3525
3526   PostMessage (HWND_BROADCAST, client_message,
3527                (WPARAM) event->client.message_type,
3528                event->client.data.l[0]);
3529 }
3530
3531 void
3532 gdk_flush (void)
3533 {
3534 #if 0
3535   MSG msg;
3536
3537   /* Process all messages currently available */
3538   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3539     {
3540       TranslateMessage (&msg);
3541       DispatchMessage (&msg);
3542     }
3543 #endif
3544
3545   GdiFlush ();
3546 }
3547
3548 void
3549 gdk_display_sync (GdkDisplay * display)
3550 {
3551   MSG msg;
3552
3553   g_return_if_fail (display == gdk_display_get_default ());
3554
3555   /* Process all messages currently available */
3556   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3557     DispatchMessage (&msg);
3558 }
3559
3560 void
3561 gdk_display_flush (GdkDisplay * display)
3562 {
3563   g_return_if_fail (display == gdk_display_get_default ());
3564
3565   /* Nothing */
3566 }
3567
3568 gboolean
3569 gdk_net_wm_supports (GdkAtom property)
3570 {
3571   return FALSE;
3572 }