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

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