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   GdkAtom target;
2182
2183   gchar buf[256];
2184   gboolean return_val = FALSE;
2185
2186   int i;
2187
2188   if (_gdk_default_filters)
2189     {
2190       /* Apply global filters */
2191
2192       GdkFilterReturn result =
2193         apply_filters (display, NULL, msg, _gdk_default_filters);
2194
2195       /* If result is GDK_FILTER_CONTINUE, we continue as if nothing
2196        * happened. If it is GDK_FILTER_REMOVE or GDK_FILTER_TRANSLATE,
2197        * we return TRUE, and DefWindowProc() will not be called.
2198        */
2199       if (result == GDK_FILTER_REMOVE ||
2200           result == GDK_FILTER_TRANSLATE)
2201         return TRUE;
2202     }
2203
2204   window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd);
2205   orig_window = window;
2206
2207   if (window == NULL)
2208     {
2209       /* XXX Handle WM_QUIT here ? */
2210       if (msg->message == WM_QUIT)
2211         {
2212           GDK_NOTE (EVENTS, g_print (" %d", msg->wParam));
2213           exit (msg->wParam);
2214         }
2215       else if (msg->message == WM_MOVE ||
2216                msg->message == WM_SIZE)
2217         {
2218           /* It's quite normal to get these messages before we have
2219            * had time to register the window in our lookup table, or
2220            * when the window is being destroyed and we already have
2221            * removed it. Repost the same message to our queue so that
2222            * we will get it later when we are prepared.
2223            */
2224           GDK_NOTE (EVENTS, g_print (" (posted)"));
2225
2226           PostMessage (msg->hwnd, msg->message,
2227                        msg->wParam, msg->lParam);
2228         }
2229       else if (msg->message == WM_CREATE)
2230         {
2231           window = (UNALIGNED GdkWindow*) (((LPCREATESTRUCT) msg->lParam)->lpCreateParams);
2232           GDK_WINDOW_HWND (window) = msg->hwnd;
2233         }
2234       else
2235         {
2236           GDK_NOTE (EVENTS, g_print (" (no GdkWindow)"));
2237         }
2238       return FALSE;
2239     }
2240
2241   g_object_ref (window);
2242
2243   /* window's refcount has now been increased, so code below should
2244    * not just return from this function, but instead goto done (or
2245    * break out of the big switch). To protect against forgetting this,
2246    * #define return to a syntax error...
2247    */
2248 #define return GOTO_DONE_INSTEAD
2249
2250   if (!GDK_WINDOW_DESTROYED (window) && ((GdkWindowObject *) window)->filters)
2251     {
2252       /* Apply per-window filters */
2253
2254       GdkFilterReturn result =
2255         apply_filters (display, window, msg, ((GdkWindowObject *) window)->filters);
2256
2257       if (result == GDK_FILTER_REMOVE ||
2258           result == GDK_FILTER_TRANSLATE)
2259         {
2260           return_val = TRUE;
2261           goto done;
2262         }
2263     }
2264
2265   if (msg->message == msh_mousewheel)
2266     {
2267       GDK_NOTE (EVENTS, g_print (" (MSH_MOUSEWHEEL)"));
2268
2269       /* MSG_MOUSEWHEEL is delivered to the foreground window.  Work
2270        * around that. Also, the position is in screen coordinates, not
2271        * client coordinates as with the button messages.
2272        */
2273       point.x = GET_X_LPARAM (msg->lParam);
2274       point.y = GET_Y_LPARAM (msg->lParam);
2275       if ((hwnd = WindowFromPoint (point)) == NULL)
2276         goto done;
2277
2278       msg->hwnd = hwnd;
2279       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2280         goto done;
2281
2282       assign_object (&window, new_window);
2283
2284       if (!propagate (&window, msg,
2285                       p_grab_window, p_grab_owner_events, p_grab_mask,
2286                       doesnt_want_scroll, TRUE))
2287         goto done;
2288
2289       if (GDK_WINDOW_DESTROYED (window))
2290         goto done;
2291
2292       ScreenToClient (msg->hwnd, &point);
2293
2294       event = gdk_event_new (GDK_SCROLL);
2295       event->scroll.window = window;
2296       event->scroll.direction = ((int) msg->wParam > 0) ?
2297         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2298       event->scroll.time = _gdk_win32_get_next_tick (msg->time);
2299       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2300       event->scroll.x = (gint16) point.x + xoffset;
2301       event->scroll.y = (gint16) point.y + yoffset;
2302       event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;
2303       event->scroll.y_root = (gint16) GET_Y_LPARAM (msg->lParam) + _gdk_offset_y;
2304       event->scroll.state = 0;  /* No state information with MSH_MOUSEWHEEL */
2305       event->scroll.device = display->core_pointer;
2306
2307       append_event (display, event);
2308
2309       return_val = TRUE;
2310       goto done;
2311     }
2312   else if (msg->message == client_message)
2313     {
2314       GList *tmp_list;
2315       GdkFilterReturn result = GDK_FILTER_CONTINUE;
2316
2317       GDK_NOTE (EVENTS, g_print (" client_message"));
2318
2319       tmp_list = client_filters;
2320       while (tmp_list)
2321         {
2322           GdkClientFilter *filter = tmp_list->data;
2323
2324           tmp_list = tmp_list->next;
2325
2326           if (filter->type == GDK_POINTER_TO_ATOM (msg->wParam))
2327             {
2328               GList *filter_list = g_list_append (NULL, filter);
2329
2330               GDK_NOTE (EVENTS, g_print (" (match)"));
2331
2332               result = apply_filters (display, window, msg, filter_list);
2333
2334               g_list_free (filter_list);
2335
2336               if (result != GDK_FILTER_CONTINUE)
2337                 break;
2338             }
2339         }
2340
2341       if (result == GDK_FILTER_REMOVE ||
2342           result == GDK_FILTER_TRANSLATE)
2343         {
2344           return_val = TRUE;
2345           goto done;
2346         }
2347       else
2348         {
2349           /* Send unknown client messages on to Gtk for it to use */
2350
2351           event = gdk_event_new (GDK_CLIENT_EVENT);
2352           event->client.window = window;
2353           event->client.message_type = GDK_POINTER_TO_ATOM (msg->wParam);
2354           event->client.data_format = 32;
2355           event->client.data.l[0] = msg->lParam;
2356           for (i = 1; i < 5; i++)
2357             event->client.data.l[i] = 0;
2358
2359           append_event (display, event);
2360
2361           return_val = TRUE;
2362           goto done;
2363         }
2364     }
2365
2366   switch (msg->message)
2367     {
2368     case WM_INPUTLANGCHANGE:
2369       _gdk_input_locale = (HKL) msg->lParam;
2370       _gdk_input_locale_is_ime = ImmIsIME (_gdk_input_locale);
2371       GetLocaleInfo (MAKELCID (LOWORD (_gdk_input_locale), SORT_DEFAULT),
2372                      LOCALE_IDEFAULTANSICODEPAGE,
2373                      buf, sizeof (buf));
2374       _gdk_input_codepage = atoi (buf);
2375       _gdk_keymap_serial++;
2376       GDK_NOTE (EVENTS,
2377                 g_print (" cs:%lu hkl:%lx%s cp:%d",
2378                          (gulong) msg->wParam,
2379                          msg->lParam, _gdk_input_locale_is_ime ? " (IME)" : "",
2380                          _gdk_input_codepage));
2381       break;
2382
2383     case WM_SYSKEYUP:
2384     case WM_SYSKEYDOWN:
2385       GDK_NOTE (EVENTS,
2386                 g_print (" %s ch:%.02x %s",
2387                          _gdk_win32_key_to_string (msg->lParam),
2388                          msg->wParam,
2389                          decode_key_lparam (msg->lParam)));
2390
2391       /* If posted without us having keyboard focus, ignore */
2392       if ((msg->wParam != VK_F10 && msg->wParam != VK_MENU) &&
2393           !(HIWORD (msg->lParam) & KF_ALTDOWN))
2394         break;
2395
2396       /* Let the system handle Alt-Tab, Alt-Space, Alt-Enter and
2397        * Alt-F4 unless the keyboard is grabbed.
2398        */
2399       if (k_grab_window == NULL &&
2400           (msg->wParam == VK_TAB ||
2401            msg->wParam == VK_SPACE ||
2402            msg->wParam == VK_RETURN ||
2403            msg->wParam == VK_F4))
2404         break;
2405
2406       /* Jump to code in common with WM_KEYUP and WM_KEYDOWN */
2407       goto keyup_or_down;
2408
2409     case WM_KEYUP:
2410     case WM_KEYDOWN:
2411       GDK_NOTE (EVENTS,
2412                 g_print (" %s ch:%.02x %s",
2413                          _gdk_win32_key_to_string (msg->lParam),
2414                          msg->wParam,
2415                          decode_key_lparam (msg->lParam)));
2416
2417     keyup_or_down:
2418
2419       /* Ignore key messages intended for the IME */
2420       if (msg->wParam == VK_PROCESSKEY ||
2421           in_ime_composition)
2422         break;
2423
2424       if (!propagate (&window, msg,
2425                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2426                       doesnt_want_key, FALSE))
2427         break;
2428
2429       if (GDK_WINDOW_DESTROYED (window))
2430         break;
2431
2432       event = gdk_event_new ((msg->message == WM_KEYDOWN ||
2433                               msg->message == WM_SYSKEYDOWN) ?
2434                              GDK_KEY_PRESS : GDK_KEY_RELEASE);
2435       event->key.window = window;
2436       event->key.time = _gdk_win32_get_next_tick (msg->time);
2437       event->key.keyval = GDK_VoidSymbol;
2438       event->key.string = NULL;
2439       event->key.length = 0;
2440       event->key.hardware_keycode = msg->wParam;
2441       if (HIWORD (msg->lParam) & KF_EXTENDED)
2442         {
2443           switch (msg->wParam)
2444             {
2445             case VK_CONTROL:
2446               event->key.hardware_keycode = VK_RCONTROL;
2447               break;
2448             case VK_SHIFT:      /* Actually, KF_EXTENDED is not set
2449                                  * for the right shift key.
2450                                  */
2451               event->key.hardware_keycode = VK_RSHIFT;
2452               break;
2453             case VK_MENU:
2454               event->key.hardware_keycode = VK_RMENU;
2455               break;
2456             }
2457         }
2458       else if (msg->wParam == VK_SHIFT &&
2459                LOBYTE (HIWORD (msg->lParam)) == _scancode_rshift)
2460         event->key.hardware_keycode = VK_RSHIFT;
2461
2462       API_CALL (GetKeyboardState, (key_state));
2463
2464       /* 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]); */
2465
2466       build_key_event_state (event, key_state);
2467
2468       gdk_keymap_translate_keyboard_state (NULL,
2469                                            event->key.hardware_keycode,
2470                                            event->key.state,
2471                                            event->key.group,
2472                                            &event->key.keyval,
2473                                            NULL, NULL, NULL);
2474
2475       fill_key_event_string (event);
2476
2477       /* Reset MOD1_MASK if it is the Alt key itself */
2478       if (msg->wParam == VK_MENU)
2479         event->key.state &= ~GDK_MOD1_MASK;
2480
2481       append_event (display, event);
2482
2483       return_val = TRUE;
2484       break;
2485
2486     case WM_SYSCHAR:
2487       if (msg->wParam != VK_SPACE)
2488         {
2489           /* To prevent beeps, don't let DefWindowProc() be called */
2490           return_val = TRUE;
2491           goto done;
2492         }
2493       break;
2494
2495     case WM_IME_STARTCOMPOSITION:
2496       in_ime_composition = TRUE;
2497       break;
2498
2499     case WM_IME_ENDCOMPOSITION:
2500       in_ime_composition = FALSE;
2501       break;
2502
2503     case WM_IME_COMPOSITION:
2504       /* On Win2k WM_IME_CHAR doesn't work correctly for non-Unicode
2505        * applications. Thus, handle WM_IME_COMPOSITION with
2506        * GCS_RESULTSTR instead, fetch the Unicode chars from the IME
2507        * with ImmGetCompositionStringW().
2508        *
2509        * See for instance
2510        * http://groups.google.com/groups?selm=natX5.57%24g77.19788%40nntp2.onemain.com
2511        * and
2512        * http://groups.google.com/groups?selm=u2XfrXw5BHA.1628%40tkmsftngp02
2513        * for comments by other people that seems to have the same
2514        * experience. WM_IME_CHAR just gives question marks, apparently
2515        * because of going through some conversion to the current code
2516        * page.
2517        *
2518        * WM_IME_CHAR might work on NT4 or Win9x with ActiveIMM, but
2519        * use WM_IME_COMPOSITION there, too, to simplify the code.
2520        */
2521       GDK_NOTE (EVENTS, g_print (" %#lx", msg->lParam));
2522
2523       if (!(msg->lParam & GCS_RESULTSTR))
2524         break;
2525
2526       if (!propagate (&window, msg,
2527                       k_grab_window, k_grab_owner_events, GDK_ALL_EVENTS_MASK,
2528                       doesnt_want_char, FALSE))
2529         break;
2530
2531       if (GDK_WINDOW_DESTROYED (window))
2532         break;
2533
2534       himc = ImmGetContext (msg->hwnd);
2535       ccount = ImmGetCompositionStringW (himc, GCS_RESULTSTR,
2536                                          wbuf, sizeof (wbuf));
2537       ImmReleaseContext (msg->hwnd, himc);
2538
2539       ccount /= 2;
2540
2541       API_CALL (GetKeyboardState, (key_state));
2542
2543       for (i = 0; i < ccount; i++)
2544         {
2545           if (((GdkWindowObject *) window)->event_mask & GDK_KEY_PRESS_MASK)
2546             {
2547               /* Build a key press event */
2548               event = gdk_event_new (GDK_KEY_PRESS);
2549               event->key.window = window;
2550               build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
2551
2552               append_event (display, event);
2553             }
2554
2555           if (((GdkWindowObject *) window)->event_mask & GDK_KEY_RELEASE_MASK)
2556             {
2557               /* Build a key release event.  */
2558               event = gdk_event_new (GDK_KEY_RELEASE);
2559               event->key.window = window;
2560               build_wm_ime_composition_event (event, msg, wbuf[i], key_state);
2561
2562               append_event (display, event);
2563             }
2564         }
2565       return_val = TRUE;
2566       break;
2567
2568     case WM_LBUTTONDOWN:
2569       button = 1;
2570       goto buttondown0;
2571
2572     case WM_MBUTTONDOWN:
2573       button = 2;
2574       goto buttondown0;
2575
2576     case WM_RBUTTONDOWN:
2577       button = 3;
2578       goto buttondown0;
2579
2580     case WM_XBUTTONDOWN:
2581       if (HIWORD (msg->wParam) == XBUTTON1)
2582         button = 4;
2583       else
2584         button = 5;
2585
2586     buttondown0:
2587       GDK_NOTE (EVENTS,
2588                 g_print (" (%d,%d)",
2589                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2590
2591       assign_object (&window, find_window_for_mouse_event (window, msg));
2592
2593       if (p_grab_window != NULL)
2594         {
2595           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2596
2597           if (real_window != current_window)
2598             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2599         }
2600       else
2601         {
2602           if (window != current_window)
2603             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2604         }
2605
2606       if (!propagate (&window, msg,
2607                       p_grab_window, p_grab_owner_events, p_grab_mask,
2608                       doesnt_want_button_press, TRUE))
2609         break;
2610
2611       if (GDK_WINDOW_DESTROYED (window))
2612         break;
2613
2614       /* Emulate X11's automatic active grab */
2615       if (!p_grab_window)
2616         {
2617           /* No explicit active grab, let's start one automatically */
2618           GDK_NOTE (EVENTS, g_print (" (automatic grab)"));
2619           gdk_pointer_grab (window,
2620                             FALSE,
2621                             ((GdkWindowObject *) window)->event_mask,
2622                             NULL, NULL, 0);
2623           p_grab_automatic = TRUE;
2624         }
2625
2626       event = gdk_event_new (GDK_BUTTON_PRESS);
2627       event->button.window = window;
2628       event->button.time = _gdk_win32_get_next_tick (msg->time);
2629       if (window != orig_window)
2630         translate_mouse_coords (orig_window, window, msg);
2631       event->button.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2632       event->button.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2633       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2634       event->button.x += xoffset;
2635       event->button.y += yoffset;
2636       event->button.x_root = msg->pt.x + _gdk_offset_x;
2637       event->button.y_root = msg->pt.y + _gdk_offset_y;
2638       event->button.axes = NULL;
2639       event->button.state = build_pointer_event_state (msg);
2640       event->button.button = button;
2641       event->button.device = display->core_pointer;
2642
2643       append_event (display, event);
2644
2645       _gdk_event_button_generate (display, event);
2646
2647       return_val = TRUE;
2648       break;
2649
2650     case WM_LBUTTONUP:
2651       button = 1;
2652       goto buttonup0;
2653
2654     case WM_MBUTTONUP:
2655       button = 2;
2656       goto buttonup0;
2657
2658     case WM_RBUTTONUP:
2659       button = 3;
2660       goto buttonup0;
2661
2662     case WM_XBUTTONUP:
2663       if (HIWORD (msg->wParam) == XBUTTON1)
2664         button = 4;
2665       else
2666         button = 5;
2667
2668     buttonup0:
2669       GDK_NOTE (EVENTS,
2670                 g_print (" (%d,%d)",
2671                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2672
2673       assign_object (&window, find_window_for_mouse_event (window, msg));
2674
2675       if (p_grab_window != NULL)
2676         {
2677           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2678
2679           if (real_window != current_window)
2680             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2681         }
2682       else
2683         {
2684           if (window != current_window)
2685             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2686         }
2687
2688 #if 0
2689       if (((GdkWindowObject *) window)->extension_events != 0 &&
2690           _gdk_input_ignore_core)
2691         {
2692           GDK_NOTE (EVENTS, g_print (" (ignored)"));
2693           break;
2694         }
2695 #endif
2696
2697       if (!propagate (&window, msg,
2698                       p_grab_window, p_grab_owner_events, p_grab_mask,
2699                       doesnt_want_button_release, TRUE))
2700         {
2701         }
2702       else if (!GDK_WINDOW_DESTROYED (window))
2703         {
2704           event = gdk_event_new (GDK_BUTTON_RELEASE);
2705           event->button.window = window;
2706           event->button.time = _gdk_win32_get_next_tick (msg->time);
2707           if (window != orig_window)
2708             translate_mouse_coords (orig_window, window, msg);
2709           event->button.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2710           event->button.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2711           _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2712           event->button.x += xoffset;
2713           event->button.y += yoffset;
2714           event->button.x_root = msg->pt.x + _gdk_offset_x;
2715           event->button.y_root = msg->pt.y + _gdk_offset_y;
2716           event->button.axes = NULL;
2717           event->button.state = build_pointer_event_state (msg);
2718           event->button.button = button;
2719           event->button.device = display->core_pointer;
2720
2721           append_event (display, event);
2722         }
2723
2724       if (p_grab_window != NULL &&
2725           p_grab_automatic &&
2726           (msg->wParam & (MK_LBUTTON | MK_MBUTTON | MK_RBUTTON)) == 0)
2727         {
2728           /* Terminate automatic grab */
2729           gdk_pointer_ungrab (0);
2730         }
2731
2732       return_val = TRUE;
2733       break;
2734
2735     case WM_MOUSEMOVE:
2736       GDK_NOTE (EVENTS,
2737                 g_print (" %#x (%d,%d)",
2738                          msg->wParam,
2739                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2740
2741       assign_object (&window, find_window_for_mouse_event (window, msg));
2742
2743       if (p_grab_window != NULL)
2744         {
2745           GdkWindow *real_window = find_real_window_for_grabbed_mouse_event (window, msg);
2746
2747           if (real_window != current_window)
2748             synthesize_crossing_events (real_window, GDK_CROSSING_NORMAL, msg);
2749         }
2750       else
2751         {
2752           if (window != current_window)
2753             synthesize_crossing_events (window, GDK_CROSSING_NORMAL, msg);
2754         }
2755
2756       if (!propagate (&window, msg,
2757                       p_grab_window, p_grab_owner_events, p_grab_mask,
2758                       doesnt_want_button_motion, TRUE))
2759         break;
2760
2761       if (GDK_WINDOW_DESTROYED (window))
2762         break;
2763
2764       if (window != orig_window)
2765         translate_mouse_coords (orig_window, window, msg);
2766
2767       /* If we haven't moved, don't create any event.
2768        * Windows sends WM_MOUSEMOVE messages after button presses
2769        * even if the mouse doesn't move. This disturbs gtk.
2770        */
2771       if (window == current_window &&
2772           GET_X_LPARAM (msg->lParam) == current_x &&
2773           GET_Y_LPARAM (msg->lParam) == current_y)
2774         break;
2775
2776       event = gdk_event_new (GDK_MOTION_NOTIFY);
2777       event->motion.window = window;
2778       event->motion.time = _gdk_win32_get_next_tick (msg->time);
2779       event->motion.x = current_x = (gint16) GET_X_LPARAM (msg->lParam);
2780       event->motion.y = current_y = (gint16) GET_Y_LPARAM (msg->lParam);
2781       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2782       event->motion.x += xoffset;
2783       event->motion.y += yoffset;
2784       event->motion.x_root = msg->pt.x + _gdk_offset_x;
2785       event->motion.y_root = msg->pt.y + _gdk_offset_y;
2786       event->motion.axes = NULL;
2787       event->motion.state = build_pointer_event_state (msg);
2788       event->motion.is_hint = FALSE;
2789       event->motion.device = display->core_pointer;
2790
2791       append_event (display, event);
2792
2793       return_val = TRUE;
2794       break;
2795
2796     case WM_NCMOUSEMOVE:
2797       GDK_NOTE (EVENTS,
2798                 g_print (" (%d,%d)",
2799                          GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
2800       if (current_window != NULL &&
2801           (((GdkWindowObject *) current_window)->event_mask & GDK_LEAVE_NOTIFY_MASK))
2802         {
2803           synthesize_crossing_events (_gdk_root, GDK_CROSSING_NORMAL, msg);
2804         }
2805
2806       break;
2807
2808     case WM_MOUSELEAVE:
2809       GDK_NOTE (EVENTS, g_print (" %d (%ld,%ld)",
2810                                  HIWORD (msg->wParam), msg->pt.x, msg->pt.y));
2811
2812       if (!gdk_win32_handle_table_lookup ((GdkNativeWindow) WindowFromPoint (msg->pt)))
2813         {
2814           GdkNotifyType detail;
2815
2816           if (GDK_WINDOW_TYPE (current_window) != GDK_WINDOW_CHILD)
2817             detail = GDK_NOTIFY_ANCESTOR;
2818           else
2819             detail = GDK_NOTIFY_UNKNOWN;
2820
2821           /* we are only interested if we don't know the new window */
2822           synthesize_enter_or_leave_event (current_window, msg,
2823                                            GDK_LEAVE_NOTIFY, GDK_CROSSING_NORMAL, detail,
2824                                            current_x, current_y);
2825         }
2826       else
2827         {
2828           GDK_NOTE (EVENTS, g_print (" (ignored)"));
2829         }
2830       return_val = TRUE;
2831       break;
2832
2833     case WM_MOUSEWHEEL:
2834       GDK_NOTE (EVENTS, g_print (" %d", HIWORD (msg->wParam)));
2835
2836       /* WM_MOUSEWHEEL is delivered to the focus window. Work around
2837        * that. Also, the position is in screen coordinates, not client
2838        * coordinates as with the button messages. I love the
2839        * consistency of Windows.
2840        */
2841       point.x = GET_X_LPARAM (msg->lParam);
2842       point.y = GET_Y_LPARAM (msg->lParam);
2843
2844       if ((hwnd = WindowFromPoint (point)) == NULL)
2845         break;
2846
2847       msg->hwnd = hwnd;
2848       if ((new_window = gdk_win32_handle_table_lookup ((GdkNativeWindow) msg->hwnd)) == NULL)
2849         break;
2850
2851       if (new_window != window)
2852         {
2853           assign_object (&window, new_window);
2854         }
2855
2856       if (!propagate (&window, msg,
2857                       p_grab_window, p_grab_owner_events, p_grab_mask,
2858                       doesnt_want_scroll, TRUE))
2859         break;
2860
2861       if (GDK_WINDOW_DESTROYED (window))
2862         break;
2863
2864       ScreenToClient (msg->hwnd, &point);
2865
2866       event = gdk_event_new (GDK_SCROLL);
2867       event->scroll.window = window;
2868       event->scroll.direction = (((short) HIWORD (msg->wParam)) > 0) ?
2869         GDK_SCROLL_UP : GDK_SCROLL_DOWN;
2870       event->scroll.window = window;
2871       event->scroll.time = _gdk_win32_get_next_tick (msg->time);
2872       _gdk_windowing_window_get_offsets (window, &xoffset, &yoffset);
2873       event->scroll.x = (gint16) point.x + xoffset;
2874       event->scroll.y = (gint16) point.y + yoffset;
2875       event->scroll.x_root = (gint16) GET_X_LPARAM (msg->lParam) + _gdk_offset_x;
2876       event->scroll.y_root = (gint16) GET_Y_LPARAM (msg->lParam) + _gdk_offset_y;
2877       event->scroll.state = build_pointer_event_state (msg);
2878       event->scroll.device = display->core_pointer;
2879
2880       append_event (display, event);
2881
2882       return_val = TRUE;
2883       break;
2884
2885     case WM_QUERYNEWPALETTE:
2886       if (gdk_visual_get_system ()->type == GDK_VISUAL_PSEUDO_COLOR)
2887         {
2888           synthesize_expose_events (window);
2889           update_colors_counter = 0;
2890         }
2891       return_val = TRUE;
2892       break;
2893
2894     case WM_PALETTECHANGED:
2895       GDK_NOTE (EVENTS_OR_COLORMAP, g_print (" %p", (HWND) msg->wParam));
2896       if (gdk_visual_get_system ()->type != GDK_VISUAL_PSEUDO_COLOR)
2897         break;
2898
2899       return_val = TRUE;
2900
2901       if (msg->hwnd == (HWND) msg->wParam)
2902         break;
2903
2904       if (++update_colors_counter == 5)
2905         {
2906           synthesize_expose_events (window);
2907           update_colors_counter = 0;
2908           break;
2909         }
2910
2911       update_colors (window, TRUE);
2912       break;
2913
2914      case WM_MOUSEACTIVATE:
2915        if (gdk_window_get_window_type (window) == GDK_WINDOW_TEMP)
2916          {
2917            *ret_valp = MA_NOACTIVATE;
2918            return_val = TRUE;
2919          }
2920        break;
2921
2922     case WM_KILLFOCUS:
2923       if (p_grab_window != NULL && !GDK_WINDOW_DESTROYED (p_grab_window))
2924         {
2925           event = gdk_event_new (GDK_GRAB_BROKEN);
2926           event->grab_broken.window = p_grab_window;
2927           event->grab_broken.send_event = 0;
2928           event->grab_broken.keyboard = FALSE;
2929
2930           append_event (display, event);
2931         }
2932       if (k_grab_window != NULL && !GDK_WINDOW_DESTROYED (k_grab_window)
2933           && k_grab_window != p_grab_window)
2934         {
2935           event = gdk_event_new (GDK_GRAB_BROKEN);
2936           event->grab_broken.window = k_grab_window;
2937           event->grab_broken.send_event = 0;
2938           event->grab_broken.keyboard = TRUE;
2939
2940           append_event (display, event);
2941         }
2942
2943       /* fallthrough */
2944     case WM_SETFOCUS:
2945       if (k_grab_window != NULL && !k_grab_owner_events)
2946         break;
2947
2948       if (!(((GdkWindowObject *) window)->event_mask & GDK_FOCUS_CHANGE_MASK))
2949         break;
2950
2951       if (GDK_WINDOW_DESTROYED (window))
2952         break;
2953
2954       generate_focus_event (window, (msg->message == WM_SETFOCUS));
2955       return_val = TRUE;
2956       break;
2957
2958     case WM_ERASEBKGND:
2959       GDK_NOTE (EVENTS, g_print (" %p", (HANDLE) msg->wParam));
2960
2961       if (GDK_WINDOW_DESTROYED (window))
2962         break;
2963
2964       erase_background (window, (HDC) msg->wParam);
2965       return_val = TRUE;
2966       *ret_valp = 1;
2967       break;
2968
2969     case WM_PAINT:
2970       handle_wm_paint (msg, window, FALSE, NULL);
2971       break;
2972
2973     case WM_SETCURSOR:
2974       GDK_NOTE (EVENTS, g_print (" %#x %#x",
2975                                  LOWORD (msg->lParam), HIWORD (msg->lParam)));
2976
2977       if (p_grab_window == NULL && LOWORD (msg->lParam) != HTCLIENT)
2978         break;
2979
2980       if (p_grab_window != NULL && p_grab_cursor != NULL)
2981         hcursor = p_grab_cursor;
2982       else if (!GDK_WINDOW_DESTROYED (window))
2983         hcursor = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->hcursor;
2984       else
2985         hcursor = NULL;
2986
2987       if (hcursor != NULL)
2988         {
2989           GDK_NOTE (EVENTS, g_print (" (SetCursor(%p)", hcursor));
2990           SetCursor (hcursor);
2991           return_val = TRUE;
2992           *ret_valp = TRUE;
2993         }
2994       break;
2995
2996     case WM_SHOWWINDOW:
2997       GDK_NOTE (EVENTS, g_print (" %d", msg->wParam));
2998
2999       if (!(((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK))
3000         break;
3001
3002       if (msg->lParam == SW_OTHERUNZOOM ||
3003           msg->lParam == SW_OTHERZOOM)
3004         break;
3005
3006       if (GDK_WINDOW_DESTROYED (window))
3007         break;
3008
3009       event = gdk_event_new (msg->wParam ? GDK_MAP : GDK_UNMAP);
3010       event->any.window = window;
3011
3012       append_event (display, event);
3013
3014       if (event->any.type == GDK_UNMAP &&
3015           p_grab_window == window)
3016         gdk_pointer_ungrab (msg->time);
3017
3018       if (event->any.type == GDK_UNMAP &&
3019           k_grab_window == window)
3020         gdk_keyboard_ungrab (msg->time);
3021
3022       return_val = TRUE;
3023       break;
3024
3025     case WM_SIZE:
3026       GDK_NOTE (EVENTS,
3027                 g_print (" %s %dx%d",
3028                          (msg->wParam == SIZE_MAXHIDE ? "MAXHIDE" :
3029                           (msg->wParam == SIZE_MAXIMIZED ? "MAXIMIZED" :
3030                            (msg->wParam == SIZE_MAXSHOW ? "MAXSHOW" :
3031                             (msg->wParam == SIZE_MINIMIZED ? "MINIMIZED" :
3032                              (msg->wParam == SIZE_RESTORED ? "RESTORED" : "?"))))),
3033                          LOWORD (msg->lParam), HIWORD (msg->lParam)));
3034
3035       if (msg->wParam == SIZE_MINIMIZED)
3036         {
3037           /* Don't generate any GDK event. This is *not* an UNMAP. */
3038
3039           if (p_grab_window == window)
3040             gdk_pointer_ungrab (msg->time);
3041
3042           if (k_grab_window == window)
3043             gdk_keyboard_ungrab (msg->time);
3044
3045           gdk_synthesize_window_state (window,
3046                                        GDK_WINDOW_STATE_WITHDRAWN,
3047                                        GDK_WINDOW_STATE_ICONIFIED);
3048         }
3049       else if ((msg->wParam == SIZE_RESTORED ||
3050                 msg->wParam == SIZE_MAXIMIZED) &&
3051                GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD)
3052         {
3053           GdkWindowState withdrawn_bit =
3054             IsWindowVisible (msg->hwnd) ? GDK_WINDOW_STATE_WITHDRAWN : 0;
3055
3056           if (!GDK_WINDOW_DESTROYED (window))
3057             handle_configure_event (msg, window);
3058
3059           if (msg->wParam == SIZE_RESTORED)
3060             gdk_synthesize_window_state (window,
3061                                          GDK_WINDOW_STATE_ICONIFIED |
3062                                          GDK_WINDOW_STATE_MAXIMIZED |
3063                                          withdrawn_bit,
3064                                          0);
3065           else if (msg->wParam == SIZE_MAXIMIZED)
3066             gdk_synthesize_window_state (window,
3067                                          GDK_WINDOW_STATE_ICONIFIED |
3068                                          withdrawn_bit,
3069                                          GDK_WINDOW_STATE_MAXIMIZED);
3070
3071           if (((GdkWindowObject *) window)->resize_count > 1)
3072             ((GdkWindowObject *) window)->resize_count -= 1;
3073
3074           if (((GdkWindowObject *) window)->extension_events != 0)
3075             _gdk_input_configure_event (window);
3076
3077           return_val = TRUE;
3078         }
3079       break;
3080
3081     case WM_ENTERSIZEMOVE:
3082       _sizemove_in_progress = TRUE;
3083       resize_timer = SetTimer (NULL, 0, 20, resize_timer_proc);
3084       break;
3085
3086     case WM_EXITSIZEMOVE:
3087       _sizemove_in_progress = FALSE;
3088       KillTimer (NULL, resize_timer);
3089       break;
3090
3091     case WM_WINDOWPOSCHANGED :
3092       /* Once we've entered the moving or sizing modal loop, we won't
3093        * return to the main loop until we're done sizing or moving.
3094        */
3095       if (_sizemove_in_progress &&
3096          GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&
3097          !GDK_WINDOW_DESTROYED (window))
3098         {
3099           RECT client_rect;
3100           POINT point;
3101
3102           GetClientRect (msg->hwnd, &client_rect);
3103           point.x = client_rect.left; /* always 0 */
3104           point.y = client_rect.top;
3105           /* top level windows need screen coords */
3106           if (gdk_window_get_parent (window) == _gdk_root)
3107             {
3108               ClientToScreen (msg->hwnd, &point);
3109               point.x += _gdk_offset_x;
3110               point.y += _gdk_offset_y;
3111             }
3112
3113           GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->width = client_rect.right - client_rect.left;
3114           GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl)->height = client_rect.bottom - client_rect.top;
3115
3116           ((GdkWindowObject *) window)->x = point.x;
3117           ((GdkWindowObject *) window)->y = point.y;
3118
3119           if (((GdkWindowObject *) window)->event_mask & GDK_STRUCTURE_MASK)
3120             {
3121               GdkEvent *event = gdk_event_new (GDK_CONFIGURE);
3122
3123               event->configure.window = window;
3124
3125               event->configure.width = client_rect.right - client_rect.left;
3126               event->configure.height = client_rect.bottom - client_rect.top;
3127
3128               event->configure.x = point.x;
3129               event->configure.y = point.y;
3130
3131               if (((GdkWindowObject *) window)->resize_count > 1)
3132                 ((GdkWindowObject *) window)->resize_count -= 1;
3133
3134 #if 0 /* I don't like calling _gdk_event_func() from here, isn't there
3135        * a risk of getting events processed in the wrong order, like
3136        * Owen says in the discussion of bug #99540?
3137        */
3138               fixup_event (event);
3139               if (_gdk_event_func)
3140                 (*_gdk_event_func) (event, _gdk_event_data);
3141               gdk_event_free (event);
3142 #else /* Calling append_event() is slower, but guarantees that events won't
3143        * get reordered, I think.
3144        */
3145               append_event (display, event);
3146 #endif
3147
3148               /* Dispatch main loop - to realize resizes... */
3149               handle_stuff_while_moving_or_resizing ();
3150
3151               /* Claim as handled, so that WM_SIZE and WM_MOVE are avoided */
3152               return_val = TRUE;
3153               *ret_valp = 1;
3154             }
3155         }
3156       break;
3157
3158     case WM_SIZING:
3159       GetWindowRect (GDK_WINDOW_HWND (window), &rect);
3160       GDK_NOTE (EVENTS, g_print (" %s curr:%s drag:%s",
3161                                  (msg->wParam == WMSZ_BOTTOM ? "BOTTOM" :
3162                                   (msg->wParam == WMSZ_BOTTOMLEFT ? "BOTTOMLEFT" :
3163                                    (msg->wParam == WMSZ_LEFT ? "LEFT" :
3164                                     (msg->wParam == WMSZ_TOPLEFT ? "TOPLEFT" :
3165                                      (msg->wParam == WMSZ_TOP ? "TOP" :
3166                                       (msg->wParam == WMSZ_TOPRIGHT ? "TOPRIGHT" :
3167                                        (msg->wParam == WMSZ_RIGHT ? "RIGHT" :
3168
3169                                         (msg->wParam == WMSZ_BOTTOMRIGHT ? "BOTTOMRIGHT" :
3170                                          "???")))))))),
3171                                  _gdk_win32_rect_to_string (&rect),
3172                                  _gdk_win32_rect_to_string ((RECT *) msg->lParam)));
3173
3174       impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
3175       drag = (RECT *) msg->lParam;
3176       orig_drag = *drag;
3177       if (impl->hint_flags & GDK_HINT_RESIZE_INC)
3178         {
3179           if (impl->hint_flags & GDK_HINT_BASE_SIZE)
3180             {
3181               /* Resize in increments relative to the base size */
3182               rect.left = rect.top = 0;
3183               rect.right = impl->hints.base_width;
3184               rect.bottom = impl->hints.base_height;
3185               _gdk_win32_adjust_client_rect (window, &rect);
3186               point.x = rect.left;
3187               point.y = rect.top;
3188               ClientToScreen (GDK_WINDOW_HWND (window), &point);
3189               rect.left = point.x;
3190               rect.top = point.y;
3191               point.x = rect.right;
3192               point.y = rect.bottom;
3193               ClientToScreen (GDK_WINDOW_HWND (window), &point);
3194               rect.right = point.x;
3195               rect.bottom = point.y;
3196
3197               GDK_NOTE (EVENTS, g_print (" (also BASE_SIZE, using %s)",
3198                                          _gdk_win32_rect_to_string (&rect)));
3199             }
3200
3201           switch (msg->wParam)
3202             {
3203             case WMSZ_BOTTOM:
3204               if (drag->bottom == rect.bottom)
3205                 break;
3206               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3207
3208               break;
3209
3210             case WMSZ_BOTTOMLEFT:
3211               if (drag->bottom == rect.bottom && drag->left == rect.left)
3212                 break;
3213               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3214               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3215               break;
3216
3217             case WMSZ_LEFT:
3218               if (drag->left == rect.left)
3219                 break;
3220               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3221               break;
3222
3223             case WMSZ_TOPLEFT:
3224               if (drag->top == rect.top && drag->left == rect.left)
3225                 break;
3226               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3227               adjust_drag (&drag->left, rect.left, impl->hints.width_inc);
3228               break;
3229
3230             case WMSZ_TOP:
3231               if (drag->top == rect.top)
3232                 break;
3233               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3234               break;
3235
3236             case WMSZ_TOPRIGHT:
3237               if (drag->top == rect.top && drag->right == rect.right)
3238                 break;
3239               adjust_drag (&drag->top, rect.top, impl->hints.height_inc);
3240               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3241               break;
3242
3243             case WMSZ_RIGHT:
3244               if (drag->right == rect.right)
3245                 break;
3246               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3247               break;
3248
3249             case WMSZ_BOTTOMRIGHT:
3250               if (drag->bottom == rect.bottom && drag->right == rect.right)
3251                 break;
3252               adjust_drag (&drag->bottom, rect.bottom, impl->hints.height_inc);
3253               adjust_drag (&drag->right, rect.right, impl->hints.width_inc);
3254               break;
3255             }
3256
3257           if (drag->bottom != orig_drag.bottom || drag->left != orig_drag.left ||
3258               drag->top != orig_drag.top || drag->right != orig_drag.right)
3259             {
3260               *ret_valp = TRUE;
3261               return_val = TRUE;
3262               GDK_NOTE (EVENTS, g_print (" (handled RESIZE_INC: drag:%s)",
3263                                          _gdk_win32_rect_to_string (drag)));
3264             }
3265         }
3266
3267       /* WM_GETMINMAXINFO handles min_size and max_size hints? */
3268
3269       if (impl->hint_flags & GDK_HINT_ASPECT)
3270         {
3271           gdouble drag_aspect = (gdouble) (drag->right - drag->left) / (drag->bottom - drag->top);
3272
3273           GDK_NOTE (EVENTS, g_print (" (aspect:%g)", drag_aspect));
3274           if (drag_aspect < impl->hints.min_aspect ||
3275               drag_aspect > impl->hints.max_aspect)
3276             {
3277               *drag = rect;
3278               *ret_valp = TRUE;
3279               return_val = TRUE;
3280               GDK_NOTE (EVENTS, g_print (" (handled ASPECT: drag:%s)",
3281                                          _gdk_win32_rect_to_string (drag)));
3282             }
3283         }
3284       break;
3285
3286     case WM_GETMINMAXINFO:
3287       if (GDK_WINDOW_DESTROYED (window))
3288         break;
3289
3290       impl = GDK_WINDOW_IMPL_WIN32 (((GdkWindowObject *) window)->impl);
3291       mmi = (MINMAXINFO*) msg->lParam;
3292       GDK_NOTE (EVENTS, g_print (" (mintrack:%ldx%ld maxtrack:%ldx%ld "
3293                                  "maxpos:%+ld%+ld maxsize:%ldx%ld)",
3294                                  mmi->ptMinTrackSize.x, mmi->ptMinTrackSize.y,
3295                                  mmi->ptMaxTrackSize.x, mmi->ptMaxTrackSize.y,
3296                                  mmi->ptMaxPosition.x, mmi->ptMaxPosition.y,
3297                                  mmi->ptMaxSize.x, mmi->ptMaxSize.y));
3298
3299       if (impl->hint_flags & GDK_HINT_MIN_SIZE)
3300         {
3301           rect.left = rect.top = 0;
3302           rect.right = impl->hints.min_width;
3303           rect.bottom = impl->hints.min_height;
3304
3305           _gdk_win32_adjust_client_rect (window, &rect);
3306
3307           mmi->ptMinTrackSize.x = rect.right - rect.left;
3308           mmi->ptMinTrackSize.y = rect.bottom - rect.top;
3309         }
3310
3311       if (impl->hint_flags & GDK_HINT_MAX_SIZE)
3312         {
3313           int maxw, maxh;
3314
3315           rect.left = rect.top = 0;
3316           rect.right = impl->hints.max_width;
3317           rect.bottom = impl->hints.max_height;
3318
3319           _gdk_win32_adjust_client_rect (window, &rect);
3320
3321           /* at least on win9x we have the 16 bit trouble */
3322           maxw = rect.right - rect.left;
3323           maxh = rect.bottom - rect.top;
3324           mmi->ptMaxTrackSize.x = maxw > 0 && maxw < G_MAXSHORT ? maxw : G_MAXSHORT;
3325           mmi->ptMaxTrackSize.y = maxh > 0 && maxh < G_MAXSHORT ? maxh : G_MAXSHORT;
3326         }
3327
3328       if (impl->hint_flags & (GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE))
3329         {
3330           /* Don't call DefWindowProc() */
3331           GDK_NOTE (EVENTS, g_print (" (handled, mintrack:%ldx%ld maxtrack:%ldx%ld "
3332                                      "maxpos:%+ld%+ld maxsize:%ldx%ld)",
3333                                      mmi->ptMinTrackSize.x, mmi->ptMinTrackSize.y,
3334                                      mmi->ptMaxTrackSize.x, mmi->ptMaxTrackSize.y,
3335                                      mmi->ptMaxPosition.x, mmi->ptMaxPosition.y,
3336                                      mmi->ptMaxSize.x, mmi->ptMaxSize.y));
3337           return_val = TRUE;
3338         }
3339       break;
3340
3341     case WM_MOVE:
3342       GDK_NOTE (EVENTS, g_print (" (%d,%d)",
3343                                  GET_X_LPARAM (msg->lParam), GET_Y_LPARAM (msg->lParam)));
3344
3345       if (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&
3346           !IsIconic (msg->hwnd))
3347         {
3348           if (!GDK_WINDOW_DESTROYED (window))
3349             handle_configure_event (msg, window);
3350
3351           return_val = TRUE;
3352         }
3353       break;
3354
3355     case WM_CLOSE:
3356       if (GDK_WINDOW_DESTROYED (window))
3357         break;
3358
3359       event = gdk_event_new (GDK_DELETE);
3360       event->any.window = window;
3361
3362       append_event (display, event);
3363
3364       return_val = TRUE;
3365       break;
3366
3367     case WM_DESTROY:
3368       if (window == current_window)
3369         assign_object (&current_window, _gdk_root);
3370
3371       if (p_grab_window == window)
3372         gdk_pointer_ungrab (msg->time);
3373
3374       if (k_grab_window == window)
3375         gdk_keyboard_ungrab (msg->time);
3376
3377       if ((window != NULL) && (msg->hwnd != GetDesktopWindow ()))
3378         gdk_window_destroy_notify (window);
3379
3380       if (window == NULL || GDK_WINDOW_DESTROYED (window))
3381         break;
3382
3383       event = gdk_event_new (GDK_DESTROY);
3384       event->any.window = window;
3385
3386       append_event (display, event);
3387
3388       return_val = TRUE;
3389       break;
3390
3391     case WM_DISPLAYCHANGE:
3392       handle_display_change ();
3393       break;
3394
3395     case WM_DESTROYCLIPBOARD:
3396       if (!_ignore_destroy_clipboard)
3397         {
3398           event = gdk_event_new (GDK_SELECTION_CLEAR);
3399           event->selection.window = window;
3400           event->selection.selection = GDK_SELECTION_CLIPBOARD;
3401           event->selection.time = _gdk_win32_get_next_tick (msg->time);
3402           append_event (display, event);
3403         }
3404       else
3405         return_val = TRUE;
3406       break;
3407
3408     case WM_RENDERFORMAT:
3409       GDK_NOTE (EVENTS, g_print (" %s", _gdk_win32_cf_to_string (msg->wParam)));
3410
3411       if (!(target = g_hash_table_lookup (_format_atom_table, GINT_TO_POINTER (msg->wParam))))
3412         {
3413           GDK_NOTE (EVENTS, g_print (" (target not found)"));
3414           return_val = TRUE;
3415           break;
3416         }
3417
3418       /* We need to render to clipboard immediately, don't call
3419        * append_event()
3420        */
3421       if (_gdk_event_func)
3422         {
3423           event = gdk_event_new (GDK_SELECTION_REQUEST);
3424           event->selection.window = window;
3425           event->selection.send_event = FALSE;
3426           event->selection.selection = GDK_SELECTION_CLIPBOARD;
3427           event->selection.target = target;
3428           event->selection.property = _gdk_selection_property;
3429           event->selection.requestor = (guint32) msg->hwnd;
3430           event->selection.time = msg->time;
3431
3432           fixup_event (event);
3433           GDK_NOTE (EVENTS, g_print (" (calling gdk_event_func)"));
3434           GDK_NOTE (EVENTS, print_event (event));
3435           (*_gdk_event_func) (event, _gdk_event_data);
3436           gdk_event_free (event);
3437
3438           /* Now the clipboard owner should have rendered */
3439           if (!_delayed_rendering_data)
3440             GDK_NOTE (EVENTS, g_print (" (no _delayed_rendering_data?)"));
3441           else
3442             {
3443               if (msg->wParam == CF_DIB)
3444                 {
3445                   _delayed_rendering_data =
3446                     _gdk_win32_selection_convert_to_dib (_delayed_rendering_data,
3447                                                          target);
3448                   if (!_delayed_rendering_data)
3449                     {
3450                       g_warning ("Cannot convert to DIB from delayed rendered image");
3451                       break;
3452                     }
3453                 }
3454               /* The requestor is holding the clipboard, no
3455                * OpenClipboard() is required/possible
3456                */
3457               API_CALL (SetClipboardData, (msg->wParam, _delayed_rendering_data));
3458               _delayed_rendering_data = NULL;
3459             }
3460         }
3461       break;
3462
3463 #ifdef HAVE_WINTAB
3464     case WM_ACTIVATE:
3465       /* Bring any tablet contexts to the top of the overlap order when
3466        * one of our windows is activated.
3467        * NOTE: It doesn't seem to work well if it is done in WM_ACTIVATEAPP
3468        * instead
3469        */
3470       if (LOWORD(msg->wParam) != WA_INACTIVE)
3471         _gdk_input_set_tablet_active ();
3472       break;
3473
3474       /* Handle WINTAB events here, as we know that gdkinput.c will
3475        * use the fixed WT_DEFBASE as lcMsgBase, and we thus can use the
3476        * constants as case labels.
3477        */
3478     case WT_PACKET:
3479       GDK_NOTE (EVENTS, g_print (" %d %#lx",
3480                                  msg->wParam, msg->lParam));
3481       goto wintab;
3482
3483     case WT_CSRCHANGE:
3484       GDK_NOTE (EVENTS, g_print (" %d %#lx",
3485                                  msg->wParam, msg->lParam));
3486       goto wintab;
3487
3488     case WT_PROXIMITY:
3489       GDK_NOTE (EVENTS, g_print (" %#x %d %d",
3490                                  msg->wParam,
3491                                  LOWORD (msg->lParam),
3492                                  HIWORD (msg->lParam)));
3493       /* Fall through */
3494     wintab:
3495
3496       event = gdk_event_new (GDK_NOTHING);
3497       event->any.window = window;
3498       g_object_ref (window);
3499       if (_gdk_input_other_event (event, msg, window))
3500         append_event (display, event);
3501       else
3502         gdk_event_free (event);
3503       break;
3504 #endif
3505     }
3506
3507 done:
3508
3509   if (window)
3510     g_object_unref (window);
3511
3512 #undef return
3513   return return_val;
3514 }
3515
3516 void
3517 _gdk_events_queue (GdkDisplay *display)
3518 {
3519   MSG msg;
3520
3521   while (!_gdk_event_queue_find_first (display) &&
3522          PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3523     {
3524       TranslateMessage (&msg);
3525       DispatchMessage (&msg);
3526     }
3527 }
3528
3529 static gboolean
3530 gdk_event_prepare (GSource *source,
3531                    gint    *timeout)
3532 {
3533   MSG msg;
3534   gboolean retval;
3535   GdkDisplay *display = gdk_display_get_default ();
3536
3537   GDK_THREADS_ENTER ();
3538
3539   *timeout = -1;
3540
3541   retval = (_gdk_event_queue_find_first (display) != NULL ||
3542             PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
3543
3544   GDK_THREADS_LEAVE ();
3545
3546   return retval;
3547 }
3548
3549 static gboolean
3550 gdk_event_check (GSource *source)
3551 {
3552   MSG msg;
3553   gboolean retval;
3554   GdkDisplay *display = gdk_display_get_default ();
3555
3556   GDK_THREADS_ENTER ();
3557
3558   if (event_poll_fd.revents & G_IO_IN)
3559     retval = (_gdk_event_queue_find_first (display) != NULL ||
3560               PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE));
3561   else
3562     retval = FALSE;
3563
3564   GDK_THREADS_LEAVE ();
3565
3566   return retval;
3567 }
3568
3569 static gboolean
3570 gdk_event_dispatch (GSource     *source,
3571                     GSourceFunc  callback,
3572                     gpointer     user_data)
3573 {
3574   GdkEvent *event;
3575   GdkDisplay *display = gdk_display_get_default ();
3576
3577   GDK_THREADS_ENTER ();
3578
3579   _gdk_events_queue (display);
3580   event = _gdk_event_unqueue (display);
3581
3582   if (event)
3583     {
3584       if (_gdk_event_func)
3585         (*_gdk_event_func) (event, _gdk_event_data);
3586
3587       gdk_event_free (event);
3588     }
3589
3590   GDK_THREADS_LEAVE ();
3591
3592   return TRUE;
3593 }
3594
3595 static void
3596 check_for_too_much_data (GdkEvent *event)
3597 {
3598   if (event->client.data.l[1] ||
3599       event->client.data.l[2] ||
3600       event->client.data.l[3] ||
3601       event->client.data.l[4])
3602     g_warning ("Only four bytes of data are passed in client messages on Win32\n");
3603 }
3604
3605 gboolean
3606 gdk_event_send_client_message_for_display (GdkDisplay     *display,
3607                                            GdkEvent       *event,
3608                                            GdkNativeWindow winid)
3609 {
3610   check_for_too_much_data (event);
3611
3612   return PostMessage ((HWND) winid, client_message,
3613                       (WPARAM) event->client.message_type,
3614                       event->client.data.l[0]);
3615 }
3616
3617 void
3618 gdk_screen_broadcast_client_message (GdkScreen *screen,
3619                                      GdkEvent  *event)
3620 {
3621   check_for_too_much_data (event);
3622
3623   PostMessage (HWND_BROADCAST, client_message,
3624                (WPARAM) event->client.message_type,
3625                event->client.data.l[0]);
3626 }
3627
3628 void
3629 gdk_flush (void)
3630 {
3631 #if 0
3632   MSG msg;
3633
3634   /* Process all messages currently available */
3635   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3636     {
3637       TranslateMessage (&msg);
3638       DispatchMessage (&msg);
3639     }
3640 #endif
3641
3642   GdiFlush ();
3643 }
3644
3645 void
3646 gdk_display_sync (GdkDisplay * display)
3647 {
3648   MSG msg;
3649
3650   g_return_if_fail (display == gdk_display_get_default ());
3651
3652   /* Process all messages currently available */
3653   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
3654     DispatchMessage (&msg);
3655 }
3656
3657 void
3658 gdk_display_flush (GdkDisplay * display)
3659 {
3660   g_return_if_fail (display == gdk_display_get_default ());
3661
3662   /* Nothing */
3663 }
3664
3665 gboolean
3666 gdk_net_wm_supports (GdkAtom property)
3667 {
3668   return FALSE;
3669 }